From ace60bb25f4960558a0f8818ab6721b4a88e0718 Mon Sep 17 00:00:00 2001 From: Martins Purins Date: Wed, 20 Sep 2023 22:21:26 +0100 Subject: [PATCH] add tokio_metrics --- datafusion-cli/Cargo.lock | 201 +- datafusion/core/Cargo.toml | 1 + datafusion/core/src/physical_plan/common.rs | 11 +- .../core/src/physical_plan/repartition/mod.rs | 25 +- .../core/src/physical_plan/sorts/sort.rs | 6 +- .../sorts/sort_preserving_merge.rs | 4 +- datafusion/core/src/physical_plan/stream.rs | 14 +- .../proto/src/generated/datafusion_json.rs | 14794 ++++++++++++++++ testing | 2 +- 9 files changed, 14949 insertions(+), 109 deletions(-) create mode 100644 datafusion/proto/src/generated/datafusion_json.rs diff --git a/datafusion-cli/Cargo.lock b/datafusion-cli/Cargo.lock index 195a0f5c5cdc..dabe9567f37d 100644 --- a/datafusion-cli/Cargo.lock +++ b/datafusion-cli/Cargo.lock @@ -32,9 +32,9 @@ dependencies = [ [[package]] name = "aho-corasick" -version = "1.0.4" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a" +checksum = "ea5d730647d4fadd988536d06fecce94b7b4f2a7efdae548f1cf4b63205518ab" dependencies = [ "memchr", ] @@ -77,9 +77,9 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15c4c2c83f81532e5845a733998b6971faca23490340a418e9b72a3ec9de12ea" +checksum = "b84bf0a05bbb2a83e5eb6fa36bb6e87baa08193c35ff52bbf6b38d8af2890e46" [[package]] name = "arrayref" @@ -322,9 +322,9 @@ dependencies = [ [[package]] name = "async-compression" -version = "0.4.1" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62b74f44609f0f91493e3082d3734d98497e094777144380ea4db9f9905dd5b6" +checksum = "bb42b2197bf15ccb092b62c74515dbd8b86d0effd934795f6687c93b6e679a2c" dependencies = [ "bzip2", "flate2", @@ -346,7 +346,7 @@ checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] @@ -557,7 +557,7 @@ dependencies = [ "hyper-rustls 0.23.2", "lazy_static", "pin-project-lite", - "rustls 0.20.8", + "rustls 0.20.9", "tokio", "tower", "tracing", @@ -673,9 +673,9 @@ dependencies = [ [[package]] name = "base64" -version = "0.21.3" +version = "0.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53" +checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2" [[package]] name = "base64-simd" @@ -754,9 +754,9 @@ dependencies = [ [[package]] name = "bstr" -version = "1.6.0" +version = "1.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05" +checksum = "4c2f7349907b712260e64b0afe2f84692af14a454be26187d9df565c7f69266a" dependencies = [ "memchr", "regex-automata", @@ -765,9 +765,9 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.13.0" +version = "3.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1" +checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" [[package]] name = "byteorder" @@ -777,9 +777,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "bytes" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be" +checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" [[package]] name = "bytes-utils" @@ -830,15 +830,15 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "chrono" -version = "0.4.26" +version = "0.4.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec837a71355b28f6556dbd569b37b3f363091c0bd4b2e735674521b4c5fd9bc5" +checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" dependencies = [ "android-tzdata", "iana-time-zone", "num-traits", "serde", - "winapi", + "windows-targets", ] [[package]] @@ -1030,14 +1030,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1f34ba9a9bcb8645379e9de8cb3ecfcf4d1c85ba66d90deb3259206fa5aa193b" dependencies = [ "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] name = "dashmap" -version = "5.5.1" +version = "5.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edd72493923899c6f10c641bdbdeddc7183d6396641d99c1a0d1597f37f92e28" +checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856" dependencies = [ "cfg-if", "hashbrown 0.14.0", @@ -1086,6 +1086,7 @@ dependencies = [ "sqlparser", "tempfile", "tokio", + "tokio-metrics", "tokio-util", "url", "uuid", @@ -1332,9 +1333,9 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "errno" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b30f669a7961ef1631673d2766cc92f52d64f7ef354d4fe0ddfd30ed52f0f4f" +checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd" dependencies = [ "errno-dragonfly", "libc", @@ -1493,7 +1494,7 @@ checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] @@ -1628,9 +1629,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b" +checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" [[package]] name = "hex" @@ -1720,7 +1721,7 @@ dependencies = [ "http", "hyper", "log", - "rustls 0.20.8", + "rustls 0.20.9", "rustls-native-certs", "tokio", "tokio-rustls 0.23.4", @@ -1928,9 +1929,9 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.147" +version = "0.2.148" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3" +checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b" [[package]] name = "libm" @@ -1940,9 +1941,9 @@ checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4" [[package]] name = "libmimalloc-sys" -version = "0.1.34" +version = "0.1.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25d058a81af0d1c22d7a1c948576bee6d673f7af3c0f35564abd6c81122f513d" +checksum = "3979b5c37ece694f1f5e51e7ecc871fdb0f517ed04ee45f88d15d6d553cb9664" dependencies = [ "cc", "libc", @@ -1950,9 +1951,9 @@ dependencies = [ [[package]] name = "linux-raw-sys" -version = "0.4.5" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503" +checksum = "1a9bad9f94746442c783ca431b22403b519cd7fbeed0533fdd6328b2f2212128" [[package]] name = "lock_api" @@ -2012,15 +2013,15 @@ dependencies = [ [[package]] name = "memchr" -version = "2.6.0" +version = "2.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76fc44e2588d5b436dbc3c6cf62aef290f90dab6235744a93dfe1cc18f451e2c" +checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c" [[package]] name = "mimalloc" -version = "0.1.38" +version = "0.1.39" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "972e5f23f6716f62665760b0f4cbf592576a80c7b879ba9beaafc0e558894127" +checksum = "fa01922b5ea280a911e323e4d2fd24b7fe5cc4042e0d2cda3c40775cdc4bdc9c" dependencies = [ "libmimalloc-sys", ] @@ -2160,15 +2161,15 @@ version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" dependencies = [ - "hermit-abi 0.3.2", + "hermit-abi 0.3.3", "libc", ] [[package]] name = "object" -version = "0.32.0" +version = "0.32.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77ac5bbd07aea88c60a577a1ce218075ffd59208b2d7ca97adf9bfc5aeb21ebe" +checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" dependencies = [ "memchr", ] @@ -2379,7 +2380,7 @@ checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] @@ -2408,14 +2409,14 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" [[package]] name = "predicates" -version = "3.0.3" +version = "3.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09963355b9f467184c04017ced4a2ba2d75cbcb4e7462690d388233253d4b1a9" +checksum = "6dfc28575c2e3f19cb3c73b93af36460ae898d426eba6fc15b9bd2a5220758a0" dependencies = [ "anstyle", "difflib", "float-cmp", - "itertools 0.10.5", + "itertools 0.11.0", "normalize-line-endings", "predicates-core", "regex", @@ -2469,9 +2470,9 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068" [[package]] name = "proc-macro2" -version = "1.0.66" +version = "1.0.67" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9" +checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328" dependencies = [ "unicode-ident", ] @@ -2566,9 +2567,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.9.4" +version = "1.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29" +checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47" dependencies = [ "aho-corasick", "memchr", @@ -2578,9 +2579,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629" +checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795" dependencies = [ "aho-corasick", "memchr", @@ -2692,9 +2693,9 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.9" +version = "0.38.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9bfe0f2582b4931a45d1fa608f8a8722e8b3c7ac54dd6d5f3b3212791fedef49" +checksum = "747c788e9ce8e92b12cd485c49ddf90723550b654b32508f979b71a7b1ecda4f" dependencies = [ "bitflags 2.4.0", "errno", @@ -2705,9 +2706,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.20.8" +version = "0.20.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f" +checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99" dependencies = [ "log", "ring", @@ -2750,9 +2751,9 @@ dependencies = [ [[package]] name = "rustls-webpki" -version = "0.101.4" +version = "0.101.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d" +checksum = "45a27e3b59326c16e23d30aeb7a36a24cc0d29e71d68ff611cdfb4a01d013bed" dependencies = [ "ring", "untrusted", @@ -2879,14 +2880,14 @@ checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] name = "serde_json" -version = "1.0.105" +version = "1.0.107" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360" +checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65" dependencies = [ "itoa", "ryu", @@ -2933,9 +2934,9 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.11.0" +version = "1.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9" +checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a" [[package]] name = "snafu" @@ -2977,9 +2978,9 @@ dependencies = [ [[package]] name = "socket2" -version = "0.5.3" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2538b18701741680e0322a2302176d3253a35388e2e62f172f64f4f16605f877" +checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e" dependencies = [ "libc", "windows-sys", @@ -3068,7 +3069,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] @@ -3090,9 +3091,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.29" +version = "2.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a" +checksum = "7303ef2c05cd654186cb250d29049a24840ca25d2747c25c0381c8d9e2f582e8" dependencies = [ "proc-macro2", "quote", @@ -3114,9 +3115,9 @@ dependencies = [ [[package]] name = "termcolor" -version = "1.2.0" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6" +checksum = "6093bad37da69aab9d123a8091e4be0aa4a03e4d601ec641c327398315f62b64" dependencies = [ "winapi-util", ] @@ -3135,22 +3136,22 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d" [[package]] name = "thiserror" -version = "1.0.47" +version = "1.0.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97a802ec30afc17eee47b2855fc72e0c4cd62be9b4efe6591edde0ec5bd68d8f" +checksum = "9d6d7a740b8a666a7e828dd00da9c0dc290dff53154ea77ac109281de90589b7" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.47" +version = "1.0.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bb623b56e39ab7dcd4b1b98bb6c8f8d907ed255b18de254088016b27a8ee19b" +checksum = "49922ecae66cc8a249b77e68d1d0623c1b2c514f0060c27cdc68bd62a1219d35" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] @@ -3228,7 +3229,7 @@ dependencies = [ "num_cpus", "parking_lot", "pin-project-lite", - "socket2 0.5.3", + "socket2 0.5.4", "tokio-macros", "windows-sys", ] @@ -3241,7 +3242,19 @@ checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", +] + +[[package]] +name = "tokio-metrics" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b2fc67d5dec41db679b9b052eb572269616926040b7831e32c8a152df77b84" +dependencies = [ + "futures-util", + "pin-project-lite", + "tokio", + "tokio-stream", ] [[package]] @@ -3250,7 +3263,7 @@ version = "0.23.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c43ee83903113e03984cb9e5cebe6c04a5116269e900e3ddba8f068a62adda59" dependencies = [ - "rustls 0.20.8", + "rustls 0.20.9", "tokio", "webpki", ] @@ -3278,9 +3291,9 @@ dependencies = [ [[package]] name = "tokio-util" -version = "0.7.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d" +checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d" dependencies = [ "bytes", "futures-core", @@ -3339,7 +3352,7 @@ checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", ] [[package]] @@ -3369,9 +3382,9 @@ dependencies = [ [[package]] name = "typenum" -version = "1.16.0" +version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba" +checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" [[package]] name = "unicode-bidi" @@ -3381,9 +3394,9 @@ checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" [[package]] name = "unicode-ident" -version = "1.0.11" +version = "1.0.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" [[package]] name = "unicode-normalization" @@ -3402,9 +3415,9 @@ checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36" [[package]] name = "unicode-width" -version = "0.1.10" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b" +checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85" [[package]] name = "untrusted" @@ -3467,9 +3480,9 @@ dependencies = [ [[package]] name = "walkdir" -version = "2.3.3" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698" +checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" dependencies = [ "same-file", "winapi-util", @@ -3511,7 +3524,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", "wasm-bindgen-shared", ] @@ -3545,7 +3558,7 @@ checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.29", + "syn 2.0.37", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -3581,9 +3594,9 @@ dependencies = [ [[package]] name = "webpki" -version = "0.22.0" +version = "0.22.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd" +checksum = "f0e74f82d49d545ad128049b7e88f6576df2da6b02e9ce565c6f533be576957e" dependencies = [ "ring", "untrusted", @@ -3613,9 +3626,9 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-util" -version = "0.1.5" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" dependencies = [ "winapi", ] diff --git a/datafusion/core/Cargo.toml b/datafusion/core/Cargo.toml index df16beddc722..cdfe7ba3c8eb 100644 --- a/datafusion/core/Cargo.toml +++ b/datafusion/core/Cargo.toml @@ -95,6 +95,7 @@ uuid = { version = "1.0", features = ["v4"] } xz2 = { version = "0.1", optional = true } zstd = { version = "0.12", optional = true, default-features = false } +tokio-metrics = "0.3.0" [dev-dependencies] async-trait = "0.1.53" diff --git a/datafusion/core/src/physical_plan/common.rs b/datafusion/core/src/physical_plan/common.rs index 19c05eaada32..437e463b70c5 100644 --- a/datafusion/core/src/physical_plan/common.rs +++ b/datafusion/core/src/physical_plan/common.rs @@ -98,6 +98,7 @@ fn build_file_list_recurse( pub(crate) fn spawn_buffered( mut input: SendableRecordBatchStream, buffer: usize, + monitor: Option>, ) -> SendableRecordBatchStream { // Use tokio only if running from a tokio context (#2201) if tokio::runtime::Handle::try_current().is_err() { @@ -108,13 +109,19 @@ pub(crate) fn spawn_buffered( let sender = builder.tx(); - builder.spawn(async move { + let task = async move { while let Some(item) = input.next().await { if sender.send(item).await.is_err() { return; } } - }); + }; + + if let Some(monitor) = monitor { + builder.spawn(monitor.instrument(task)); + } else { + builder.spawn(task); + } builder.build() } diff --git a/datafusion/core/src/physical_plan/repartition/mod.rs b/datafusion/core/src/physical_plan/repartition/mod.rs index c47c9926819b..4a4e32a3a407 100644 --- a/datafusion/core/src/physical_plan/repartition/mod.rs +++ b/datafusion/core/src/physical_plan/repartition/mod.rs @@ -473,6 +473,10 @@ impl ExecutionPlan for RepartitionExec { self.name(), partition ); + + let monitor = context + .session_config() + .get_extension::(); // lock mutexes let mut state = self.state.lock(); @@ -522,15 +526,20 @@ impl ExecutionPlan for RepartitionExec { let r_metrics = RepartitionMetrics::new(i, partition, &self.metrics); + let task = Self::pull_from_input( + self.input.clone(), + i, + txs.clone(), + self.partitioning.clone(), + r_metrics, + context.clone(), + ); let input_task: JoinHandle> = - tokio::spawn(Self::pull_from_input( - self.input.clone(), - i, - txs.clone(), - self.partitioning.clone(), - r_metrics, - context.clone(), - )); + if let Some(monitor) = monitor.as_deref() { + tokio::spawn(monitor.instrument(task)) + } else { + tokio::spawn(task) + }; // In a separate task, wait for each input to be done // (and pass along any errors, including panic!s) diff --git a/datafusion/core/src/physical_plan/sorts/sort.rs b/datafusion/core/src/physical_plan/sorts/sort.rs index f660f0acf89a..aa580eec6a04 100644 --- a/datafusion/core/src/physical_plan/sorts/sort.rs +++ b/datafusion/core/src/physical_plan/sorts/sort.rs @@ -282,7 +282,11 @@ impl ExternalSorter { .into_iter() .map(|batch| { let metrics = self.metrics.baseline.intermediate(); - Ok(spawn_buffered(self.sort_batch_stream(batch, metrics)?, 1)) + Ok(spawn_buffered( + self.sort_batch_stream(batch, metrics)?, + 1, + None, + )) }) .collect::>()?; diff --git a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs index 4534b558237b..677b979eab71 100644 --- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs +++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs @@ -39,6 +39,7 @@ use datafusion_physical_expr::{ }; use log::{debug, trace}; +use tokio_metrics::TaskMonitor; /// Sort preserving merge execution plan /// @@ -193,6 +194,7 @@ impl ExecutionPlan for SortPreservingMergeExec { "Start SortPreservingMergeExec::execute for partition: {}", partition ); + let monitor = context.session_config().get_extension::(); if 0 != partition { return Err(DataFusionError::Internal(format!( "SortPreservingMergeExec invalid partition {partition}" @@ -221,7 +223,7 @@ impl ExecutionPlan for SortPreservingMergeExec { let receivers = (0..input_partitions) .map(|partition| { let stream = self.input.execute(partition, context.clone())?; - Ok(spawn_buffered(stream, 1)) + Ok(spawn_buffered(stream, 1, monitor.clone())) }) .collect::>()?; diff --git a/datafusion/core/src/physical_plan/stream.rs b/datafusion/core/src/physical_plan/stream.rs index bdc2050b2464..df80b79484d7 100644 --- a/datafusion/core/src/physical_plan/stream.rs +++ b/datafusion/core/src/physical_plan/stream.rs @@ -106,7 +106,11 @@ impl RecordBatchReceiverStreamBuilder { ) { let output = self.tx(); - self.spawn(async move { + let monitor = context + .session_config() + .get_extension::(); + + let task = async move { let mut stream = match input.execute(partition, context) { Err(e) => { // If send fails, the plan being torn down, there @@ -146,7 +150,13 @@ impl RecordBatchReceiverStreamBuilder { return; } } - }); + }; + + if let Some(monitor) = monitor { + self.spawn(monitor.instrument(task)); + } else { + self.spawn(task); + } } /// Create a stream of all `RecordBatch`es written to `tx` diff --git a/datafusion/proto/src/generated/datafusion_json.rs b/datafusion/proto/src/generated/datafusion_json.rs new file mode 100644 index 000000000000..2c9ce402a06b --- /dev/null +++ b/datafusion/proto/src/generated/datafusion_json.rs @@ -0,0 +1,14794 @@ +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ColumnRelation { + #[prost(string, tag = "1")] + pub relation: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Column { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub relation: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DfField { + #[prost(message, optional, tag = "1")] + pub field: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub qualifier: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DfSchema { + #[prost(message, repeated, tag = "1")] + pub columns: ::prost::alloc::vec::Vec, + #[prost(map = "string, string", tag = "2")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// logical plan +/// LogicalPlan is a nested type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalPlanNode { + #[prost( + oneof = "logical_plan_node::LogicalPlanType", + tags = "1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23" + )] + pub logical_plan_type: ::core::option::Option, +} +/// Nested message and enum types in `LogicalPlanNode`. +pub mod logical_plan_node { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum LogicalPlanType { + #[prost(message, tag = "1")] + ListingScan(super::ListingTableScanNode), + #[prost(message, tag = "3")] + Projection(::prost::alloc::boxed::Box), + #[prost(message, tag = "4")] + Selection(::prost::alloc::boxed::Box), + #[prost(message, tag = "5")] + Limit(::prost::alloc::boxed::Box), + #[prost(message, tag = "6")] + Aggregate(::prost::alloc::boxed::Box), + #[prost(message, tag = "7")] + Join(::prost::alloc::boxed::Box), + #[prost(message, tag = "8")] + Sort(::prost::alloc::boxed::Box), + #[prost(message, tag = "9")] + Repartition(::prost::alloc::boxed::Box), + #[prost(message, tag = "10")] + EmptyRelation(super::EmptyRelationNode), + #[prost(message, tag = "11")] + CreateExternalTable(super::CreateExternalTableNode), + #[prost(message, tag = "12")] + Explain(::prost::alloc::boxed::Box), + #[prost(message, tag = "13")] + Window(::prost::alloc::boxed::Box), + #[prost(message, tag = "14")] + Analyze(::prost::alloc::boxed::Box), + #[prost(message, tag = "15")] + CrossJoin(::prost::alloc::boxed::Box), + #[prost(message, tag = "16")] + Values(super::ValuesNode), + #[prost(message, tag = "17")] + Extension(super::LogicalExtensionNode), + #[prost(message, tag = "18")] + CreateCatalogSchema(super::CreateCatalogSchemaNode), + #[prost(message, tag = "19")] + Union(super::UnionNode), + #[prost(message, tag = "20")] + CreateCatalog(super::CreateCatalogNode), + #[prost(message, tag = "21")] + SubqueryAlias(::prost::alloc::boxed::Box), + #[prost(message, tag = "22")] + CreateView(::prost::alloc::boxed::Box), + #[prost(message, tag = "23")] + Distinct(::prost::alloc::boxed::Box), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalExtensionNode { + #[prost(bytes = "vec", tag = "1")] + pub node: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "2")] + pub inputs: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectionColumns { + #[prost(string, repeated, tag = "1")] + pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CsvFormat { + #[prost(bool, tag = "1")] + pub has_header: bool, + #[prost(string, tag = "2")] + pub delimiter: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ParquetFormat { + #[prost(bool, tag = "1")] + pub enable_pruning: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AvroFormat {} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListingTableScanNode { + #[prost(string, tag = "1")] + pub table_name: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "2")] + pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag = "3")] + pub file_extension: ::prost::alloc::string::String, + #[prost(message, optional, tag = "4")] + pub projection: ::core::option::Option, + #[prost(message, optional, tag = "5")] + pub schema: ::core::option::Option, + #[prost(message, repeated, tag = "6")] + pub filters: ::prost::alloc::vec::Vec, + #[prost(string, repeated, tag = "7")] + pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(bool, tag = "8")] + pub collect_stat: bool, + #[prost(uint32, tag = "9")] + pub target_partitions: u32, + #[prost(oneof = "listing_table_scan_node::FileFormatType", tags = "10, 11, 12")] + pub file_format_type: ::core::option::Option< + listing_table_scan_node::FileFormatType, + >, +} +/// Nested message and enum types in `ListingTableScanNode`. +pub mod listing_table_scan_node { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum FileFormatType { + #[prost(message, tag = "10")] + Csv(super::CsvFormat), + #[prost(message, tag = "11")] + Parquet(super::ParquetFormat), + #[prost(message, tag = "12")] + Avro(super::AvroFormat), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectionNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, + #[prost(oneof = "projection_node::OptionalAlias", tags = "3")] + pub optional_alias: ::core::option::Option, +} +/// Nested message and enum types in `ProjectionNode`. +pub mod projection_node { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum OptionalAlias { + #[prost(string, tag = "3")] + Alias(::prost::alloc::string::String), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SelectionNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub expr: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SortNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, + /// Maximum number of highest/lowest rows to fetch; negative means no limit + #[prost(int64, tag = "3")] + pub fetch: i64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RepartitionNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(oneof = "repartition_node::PartitionMethod", tags = "2, 3")] + pub partition_method: ::core::option::Option, +} +/// Nested message and enum types in `RepartitionNode`. +pub mod repartition_node { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PartitionMethod { + #[prost(uint64, tag = "2")] + RoundRobin(u64), + #[prost(message, tag = "3")] + Hash(super::HashRepartition), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HashRepartition { + #[prost(message, repeated, tag = "1")] + pub hash_expr: ::prost::alloc::vec::Vec, + #[prost(uint64, tag = "2")] + pub partition_count: u64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EmptyRelationNode { + #[prost(bool, tag = "1")] + pub produce_one_row: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateExternalTableNode { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub location: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub file_type: ::prost::alloc::string::String, + #[prost(bool, tag = "4")] + pub has_header: bool, + #[prost(message, optional, tag = "5")] + pub schema: ::core::option::Option, + #[prost(string, repeated, tag = "6")] + pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(bool, tag = "7")] + pub if_not_exists: bool, + #[prost(string, tag = "8")] + pub delimiter: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub definition: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateCatalogSchemaNode { + #[prost(string, tag = "1")] + pub schema_name: ::prost::alloc::string::String, + #[prost(bool, tag = "2")] + pub if_not_exists: bool, + #[prost(message, optional, tag = "3")] + pub schema: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateCatalogNode { + #[prost(string, tag = "1")] + pub catalog_name: ::prost::alloc::string::String, + #[prost(bool, tag = "2")] + pub if_not_exists: bool, + #[prost(message, optional, tag = "3")] + pub schema: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateViewNode { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, boxed, tag = "2")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "3")] + pub or_replace: bool, + #[prost(string, tag = "4")] + pub definition: ::prost::alloc::string::String, +} +/// a node containing data for defining values list. unlike in SQL where it's two dimensional, here +/// the list is flattened, and with the field n_cols it can be parsed and partitioned into rows +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ValuesNode { + #[prost(uint64, tag = "1")] + pub n_cols: u64, + #[prost(message, repeated, tag = "2")] + pub values_list: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AnalyzeNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "2")] + pub verbose: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExplainNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "2")] + pub verbose: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub group_expr: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "3")] + pub aggr_expr: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub window_expr: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JoinNode { + #[prost(message, optional, boxed, tag = "1")] + pub left: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub right: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(enumeration = "JoinType", tag = "3")] + pub join_type: i32, + #[prost(enumeration = "JoinConstraint", tag = "4")] + pub join_constraint: i32, + #[prost(message, repeated, tag = "5")] + pub left_join_column: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "6")] + pub right_join_column: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "7")] + pub null_equals_null: bool, + #[prost(message, optional, tag = "8")] + pub filter: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistinctNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnionNode { + #[prost(message, repeated, tag = "1")] + pub inputs: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CrossJoinNode { + #[prost(message, optional, boxed, tag = "1")] + pub left: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub right: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LimitNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + /// The number of rows to skip before fetch; non-positive means don't skip any + #[prost(int64, tag = "2")] + pub skip: i64, + /// Maximum number of rows to fetch; negative means no limit + #[prost(int64, tag = "3")] + pub fetch: i64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SelectionExecNode { + #[prost(message, optional, tag = "1")] + pub expr: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubqueryAliasNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "2")] + pub alias: ::prost::alloc::string::String, +} +/// logical expressions +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalExprNode { + #[prost( + oneof = "logical_expr_node::ExprType", + tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33" + )] + pub expr_type: ::core::option::Option, +} +/// Nested message and enum types in `LogicalExprNode`. +pub mod logical_expr_node { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ExprType { + /// column references + #[prost(message, tag = "1")] + Column(super::Column), + /// alias + #[prost(message, tag = "2")] + Alias(::prost::alloc::boxed::Box), + #[prost(message, tag = "3")] + Literal(super::ScalarValue), + /// binary expressions + #[prost(message, tag = "4")] + BinaryExpr(::prost::alloc::boxed::Box), + /// aggregate expressions + #[prost(message, tag = "5")] + AggregateExpr(::prost::alloc::boxed::Box), + /// null checks + #[prost(message, tag = "6")] + IsNullExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "7")] + IsNotNullExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "8")] + NotExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "9")] + Between(::prost::alloc::boxed::Box), + #[prost(message, tag = "10")] + Case(::prost::alloc::boxed::Box), + #[prost(message, tag = "11")] + Cast(::prost::alloc::boxed::Box), + #[prost(message, tag = "12")] + Sort(::prost::alloc::boxed::Box), + #[prost(message, tag = "13")] + Negative(::prost::alloc::boxed::Box), + #[prost(message, tag = "14")] + InList(::prost::alloc::boxed::Box), + #[prost(bool, tag = "15")] + Wildcard(bool), + #[prost(message, tag = "16")] + ScalarFunction(super::ScalarFunctionNode), + #[prost(message, tag = "17")] + TryCast(::prost::alloc::boxed::Box), + /// window expressions + #[prost(message, tag = "18")] + WindowExpr(::prost::alloc::boxed::Box), + /// AggregateUDF expressions + #[prost(message, tag = "19")] + AggregateUdfExpr(::prost::alloc::boxed::Box), + /// Scalar UDF expressions + #[prost(message, tag = "20")] + ScalarUdfExpr(super::ScalarUdfExprNode), + #[prost(message, tag = "21")] + GetIndexedField(::prost::alloc::boxed::Box), + #[prost(message, tag = "22")] + GroupingSet(super::GroupingSetNode), + #[prost(message, tag = "23")] + Cube(super::CubeNode), + #[prost(message, tag = "24")] + Rollup(super::RollupNode), + #[prost(message, tag = "25")] + IsTrue(::prost::alloc::boxed::Box), + #[prost(message, tag = "26")] + IsFalse(::prost::alloc::boxed::Box), + #[prost(message, tag = "27")] + IsUnknown(::prost::alloc::boxed::Box), + #[prost(message, tag = "28")] + IsNotTrue(::prost::alloc::boxed::Box), + #[prost(message, tag = "29")] + IsNotFalse(::prost::alloc::boxed::Box), + #[prost(message, tag = "30")] + IsNotUnknown(::prost::alloc::boxed::Box), + #[prost(message, tag = "31")] + Like(::prost::alloc::boxed::Box), + #[prost(message, tag = "32")] + Ilike(::prost::alloc::boxed::Box), + #[prost(message, tag = "33")] + SimilarTo(::prost::alloc::boxed::Box), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalExprList { + #[prost(message, repeated, tag = "1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GroupingSetNode { + #[prost(message, repeated, tag = "1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CubeNode { + #[prost(message, repeated, tag = "1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RollupNode { + #[prost(message, repeated, tag = "1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetIndexedField { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub key: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNull { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotNull { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsTrue { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsFalse { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsUnknown { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotTrue { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotFalse { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotUnknown { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Not { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AliasNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "2")] + pub alias: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BinaryExprNode { + #[prost(message, optional, boxed, tag = "1")] + pub l: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub r: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "3")] + pub op: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NegativeNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InListNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub list: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "3")] + pub negated: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarFunctionNode { + #[prost(enumeration = "ScalarFunction", tag = "1")] + pub fun: i32, + #[prost(message, repeated, tag = "2")] + pub args: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateExprNode { + #[prost(enumeration = "AggregateFunction", tag = "1")] + pub aggr_function: i32, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "3")] + pub distinct: bool, + #[prost(message, optional, boxed, tag = "4")] + pub filter: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateUdfExprNode { + #[prost(string, tag = "1")] + pub fun_name: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub args: ::prost::alloc::vec::Vec, + #[prost(message, optional, boxed, tag = "3")] + pub filter: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarUdfExprNode { + #[prost(string, tag = "1")] + pub fun_name: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub args: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowExprNode { + #[prost(message, optional, boxed, tag = "4")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "5")] + pub partition_by: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "6")] + pub order_by: ::prost::alloc::vec::Vec, + #[prost(oneof = "window_expr_node::WindowFunction", tags = "1, 2")] + pub window_function: ::core::option::Option, + /// repeated LogicalExprNode filter = 7; + #[prost(oneof = "window_expr_node::WindowFrame", tags = "8")] + pub window_frame: ::core::option::Option, +} +/// Nested message and enum types in `WindowExprNode`. +pub mod window_expr_node { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum WindowFunction { + #[prost(enumeration = "super::AggregateFunction", tag = "1")] + AggrFunction(i32), + /// udaf = 3 + #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")] + BuiltInFunction(i32), + } + /// repeated LogicalExprNode filter = 7; + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum WindowFrame { + #[prost(message, tag = "8")] + Frame(super::WindowFrame), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BetweenNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "2")] + pub negated: bool, + #[prost(message, optional, boxed, tag = "3")] + pub low: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "4")] + pub high: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LikeNode { + #[prost(bool, tag = "1")] + pub negated: bool, + #[prost(message, optional, boxed, tag = "2")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "3")] + pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "4")] + pub escape_char: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ILikeNode { + #[prost(bool, tag = "1")] + pub negated: bool, + #[prost(message, optional, boxed, tag = "2")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "3")] + pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "4")] + pub escape_char: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SimilarToNode { + #[prost(bool, tag = "1")] + pub negated: bool, + #[prost(message, optional, boxed, tag = "2")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "3")] + pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "4")] + pub escape_char: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CaseNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub when_then_expr: ::prost::alloc::vec::Vec, + #[prost(message, optional, boxed, tag = "3")] + pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WhenThen { + #[prost(message, optional, tag = "1")] + pub when_expr: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub then_expr: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CastNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub arrow_type: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TryCastNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub arrow_type: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SortExprNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "2")] + pub asc: bool, + #[prost(bool, tag = "3")] + pub nulls_first: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowFrame { + #[prost(enumeration = "WindowFrameUnits", tag = "1")] + pub window_frame_units: i32, + #[prost(message, optional, tag = "2")] + pub start_bound: ::core::option::Option, + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[prost(oneof = "window_frame::EndBound", tags = "3")] + pub end_bound: ::core::option::Option, +} +/// Nested message and enum types in `WindowFrame`. +pub mod window_frame { + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum EndBound { + #[prost(message, tag = "3")] + Bound(super::WindowFrameBound), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowFrameBound { + #[prost(enumeration = "WindowFrameBoundType", tag = "1")] + pub window_frame_bound_type: i32, + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[prost(oneof = "window_frame_bound::BoundValue", tags = "2")] + pub bound_value: ::core::option::Option, +} +/// Nested message and enum types in `WindowFrameBound`. +pub mod window_frame_bound { + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum BoundValue { + #[prost(uint64, tag = "2")] + Value(u64), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Schema { + #[prost(message, repeated, tag = "1")] + pub columns: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Field { + /// name of the field + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, boxed, tag = "2")] + pub arrow_type: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "3")] + pub nullable: bool, + /// for complex data types like structs, unions + #[prost(message, repeated, tag = "4")] + pub children: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FixedSizeBinary { + #[prost(int32, tag = "1")] + pub length: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Timestamp { + #[prost(enumeration = "TimeUnit", tag = "1")] + pub time_unit: i32, + #[prost(string, tag = "2")] + pub timezone: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Decimal { + #[prost(uint64, tag = "1")] + pub whole: u64, + #[prost(uint64, tag = "2")] + pub fractional: u64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct List { + #[prost(message, optional, boxed, tag = "1")] + pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FixedSizeList { + #[prost(message, optional, boxed, tag = "1")] + pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(int32, tag = "2")] + pub list_size: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Dictionary { + #[prost(message, optional, boxed, tag = "1")] + pub key: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub value: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Struct { + #[prost(message, repeated, tag = "1")] + pub sub_field_types: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Union { + #[prost(message, repeated, tag = "1")] + pub union_types: ::prost::alloc::vec::Vec, + #[prost(enumeration = "UnionMode", tag = "2")] + pub union_mode: i32, + #[prost(int32, repeated, tag = "3")] + pub type_ids: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarListValue { + #[prost(message, optional, tag = "1")] + pub field: ::core::option::Option, + #[prost(message, repeated, tag = "2")] + pub values: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarTimestampValue { + #[prost(string, tag = "5")] + pub timezone: ::prost::alloc::string::String, + #[prost(oneof = "scalar_timestamp_value::Value", tags = "1, 2, 3, 4")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `ScalarTimestampValue`. +pub mod scalar_timestamp_value { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(int64, tag = "1")] + TimeMicrosecondValue(i64), + #[prost(int64, tag = "2")] + TimeNanosecondValue(i64), + #[prost(int64, tag = "3")] + TimeSecondValue(i64), + #[prost(int64, tag = "4")] + TimeMillisecondValue(i64), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarDictionaryValue { + #[prost(message, optional, tag = "1")] + pub index_type: ::core::option::Option, + #[prost(message, optional, boxed, tag = "2")] + pub value: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarValue { + #[prost( + oneof = "scalar_value::Value", + tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 18, 19, 20, 21, 24, 25, 26, 27" + )] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `ScalarValue`. +pub mod scalar_value { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(bool, tag = "1")] + BoolValue(bool), + #[prost(string, tag = "2")] + Utf8Value(::prost::alloc::string::String), + #[prost(string, tag = "3")] + LargeUtf8Value(::prost::alloc::string::String), + #[prost(int32, tag = "4")] + Int8Value(i32), + #[prost(int32, tag = "5")] + Int16Value(i32), + #[prost(int32, tag = "6")] + Int32Value(i32), + #[prost(int64, tag = "7")] + Int64Value(i64), + #[prost(uint32, tag = "8")] + Uint8Value(u32), + #[prost(uint32, tag = "9")] + Uint16Value(u32), + #[prost(uint32, tag = "10")] + Uint32Value(u32), + #[prost(uint64, tag = "11")] + Uint64Value(u64), + #[prost(float, tag = "12")] + Float32Value(f32), + #[prost(double, tag = "13")] + Float64Value(f64), + /// Literal Date32 value always has a unit of day + #[prost(int32, tag = "14")] + Date32Value(i32), + #[prost(message, tag = "17")] + ListValue(super::ScalarListValue), + #[prost(message, tag = "18")] + NullListValue(super::ScalarType), + #[prost(enumeration = "super::PrimitiveScalarType", tag = "19")] + NullValue(i32), + #[prost(message, tag = "20")] + Decimal128Value(super::Decimal128), + #[prost(int64, tag = "21")] + Date64Value(i64), + #[prost(int32, tag = "24")] + IntervalYearmonthValue(i32), + #[prost(int64, tag = "25")] + IntervalDaytimeValue(i64), + #[prost(message, tag = "26")] + TimestampValue(super::ScalarTimestampValue), + #[prost(message, tag = "27")] + DictionaryValue(::prost::alloc::boxed::Box), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Decimal128 { + #[prost(bytes = "vec", tag = "1")] + pub value: ::prost::alloc::vec::Vec, + #[prost(int64, tag = "2")] + pub p: i64, + #[prost(int64, tag = "3")] + pub s: i64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarType { + #[prost(oneof = "scalar_type::Datatype", tags = "1, 2")] + pub datatype: ::core::option::Option, +} +/// Nested message and enum types in `ScalarType`. +pub mod scalar_type { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Datatype { + #[prost(enumeration = "super::PrimitiveScalarType", tag = "1")] + Scalar(i32), + #[prost(message, tag = "2")] + List(super::ScalarListType), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarListType { + #[prost(string, repeated, tag = "3")] + pub field_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(enumeration = "PrimitiveScalarType", tag = "2")] + pub deepest_type: i32, +} +/// Broke out into multiple message types so that type +/// metadata did not need to be in separate message +/// All types that are of the empty message types contain no additional metadata +/// about the type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArrowType { + #[prost( + oneof = "arrow_type::ArrowTypeEnum", + tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 32, 15, 16, 31, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30" + )] + pub arrow_type_enum: ::core::option::Option, +} +/// Nested message and enum types in `ArrowType`. +pub mod arrow_type { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ArrowTypeEnum { + /// arrow::Type::NA + #[prost(message, tag = "1")] + None(super::EmptyMessage), + /// arrow::Type::BOOL + #[prost(message, tag = "2")] + Bool(super::EmptyMessage), + /// arrow::Type::UINT8 + #[prost(message, tag = "3")] + Uint8(super::EmptyMessage), + /// arrow::Type::INT8 + #[prost(message, tag = "4")] + Int8(super::EmptyMessage), + /// represents arrow::Type fields in src/arrow/type.h + #[prost(message, tag = "5")] + Uint16(super::EmptyMessage), + #[prost(message, tag = "6")] + Int16(super::EmptyMessage), + #[prost(message, tag = "7")] + Uint32(super::EmptyMessage), + #[prost(message, tag = "8")] + Int32(super::EmptyMessage), + #[prost(message, tag = "9")] + Uint64(super::EmptyMessage), + #[prost(message, tag = "10")] + Int64(super::EmptyMessage), + #[prost(message, tag = "11")] + Float16(super::EmptyMessage), + #[prost(message, tag = "12")] + Float32(super::EmptyMessage), + #[prost(message, tag = "13")] + Float64(super::EmptyMessage), + #[prost(message, tag = "14")] + Utf8(super::EmptyMessage), + #[prost(message, tag = "32")] + LargeUtf8(super::EmptyMessage), + #[prost(message, tag = "15")] + Binary(super::EmptyMessage), + #[prost(int32, tag = "16")] + FixedSizeBinary(i32), + #[prost(message, tag = "31")] + LargeBinary(super::EmptyMessage), + #[prost(message, tag = "17")] + Date32(super::EmptyMessage), + #[prost(message, tag = "18")] + Date64(super::EmptyMessage), + #[prost(enumeration = "super::TimeUnit", tag = "19")] + Duration(i32), + #[prost(message, tag = "20")] + Timestamp(super::Timestamp), + #[prost(enumeration = "super::TimeUnit", tag = "21")] + Time32(i32), + #[prost(enumeration = "super::TimeUnit", tag = "22")] + Time64(i32), + #[prost(enumeration = "super::IntervalUnit", tag = "23")] + Interval(i32), + #[prost(message, tag = "24")] + Decimal(super::Decimal), + #[prost(message, tag = "25")] + List(::prost::alloc::boxed::Box), + #[prost(message, tag = "26")] + LargeList(::prost::alloc::boxed::Box), + #[prost(message, tag = "27")] + FixedSizeList(::prost::alloc::boxed::Box), + #[prost(message, tag = "28")] + Struct(super::Struct), + #[prost(message, tag = "29")] + Union(super::Union), + #[prost(message, tag = "30")] + Dictionary(::prost::alloc::boxed::Box), + } +} +/// Useful for representing an empty enum variant in rust +/// E.G. enum example{One, Two(i32)} +/// maps to +/// message example{ +/// oneof{ +/// EmptyMessage One = 1; +/// i32 Two = 2; +/// } +/// } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EmptyMessage {} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OptimizedLogicalPlanType { + #[prost(string, tag = "1")] + pub optimizer_name: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OptimizedPhysicalPlanType { + #[prost(string, tag = "1")] + pub optimizer_name: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PlanType { + #[prost(oneof = "plan_type::PlanTypeEnum", tags = "1, 2, 3, 4, 5, 6")] + pub plan_type_enum: ::core::option::Option, +} +/// Nested message and enum types in `PlanType`. +pub mod plan_type { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PlanTypeEnum { + #[prost(message, tag = "1")] + InitialLogicalPlan(super::EmptyMessage), + #[prost(message, tag = "2")] + OptimizedLogicalPlan(super::OptimizedLogicalPlanType), + #[prost(message, tag = "3")] + FinalLogicalPlan(super::EmptyMessage), + #[prost(message, tag = "4")] + InitialPhysicalPlan(super::EmptyMessage), + #[prost(message, tag = "5")] + OptimizedPhysicalPlan(super::OptimizedPhysicalPlanType), + #[prost(message, tag = "6")] + FinalPhysicalPlan(super::EmptyMessage), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StringifiedPlan { + #[prost(message, optional, tag = "1")] + pub plan_type: ::core::option::Option, + #[prost(string, tag = "2")] + pub plan: ::prost::alloc::string::String, +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum JoinType { + Inner = 0, + Left = 1, + Right = 2, + Full = 3, + Semi = 4, + Anti = 5, +} +impl JoinType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JoinType::Inner => "INNER", + JoinType::Left => "LEFT", + JoinType::Right => "RIGHT", + JoinType::Full => "FULL", + JoinType::Semi => "SEMI", + JoinType::Anti => "ANTI", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "INNER" => Some(Self::Inner), + "LEFT" => Some(Self::Left), + "RIGHT" => Some(Self::Right), + "FULL" => Some(Self::Full), + "SEMI" => Some(Self::Semi), + "ANTI" => Some(Self::Anti), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum JoinConstraint { + On = 0, + Using = 1, +} +impl JoinConstraint { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JoinConstraint::On => "ON", + JoinConstraint::Using => "USING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ON" => Some(Self::On), + "USING" => Some(Self::Using), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ScalarFunction { + Abs = 0, + Acos = 1, + Asin = 2, + Atan = 3, + Ascii = 4, + Ceil = 5, + Cos = 6, + Digest = 7, + Exp = 8, + Floor = 9, + Ln = 10, + Log = 11, + Log10 = 12, + Log2 = 13, + Round = 14, + Signum = 15, + Sin = 16, + Sqrt = 17, + Tan = 18, + Trunc = 19, + Array = 20, + RegexpMatch = 21, + BitLength = 22, + Btrim = 23, + CharacterLength = 24, + Chr = 25, + Concat = 26, + ConcatWithSeparator = 27, + DatePart = 28, + DateTrunc = 29, + InitCap = 30, + Left = 31, + Lpad = 32, + Lower = 33, + Ltrim = 34, + Md5 = 35, + NullIf = 36, + OctetLength = 37, + Random = 38, + RegexpReplace = 39, + Repeat = 40, + Replace = 41, + Reverse = 42, + Right = 43, + Rpad = 44, + Rtrim = 45, + Sha224 = 46, + Sha256 = 47, + Sha384 = 48, + Sha512 = 49, + SplitPart = 50, + StartsWith = 51, + Strpos = 52, + Substr = 53, + ToHex = 54, + ToTimestamp = 55, + ToTimestampMillis = 56, + ToTimestampMicros = 57, + ToTimestampSeconds = 58, + Now = 59, + Translate = 60, + Trim = 61, + Upper = 62, + Coalesce = 63, + Power = 64, + StructFun = 65, + FromUnixtime = 66, + Atan2 = 67, + DateBin = 68, + ArrowTypeof = 69, +} +impl ScalarFunction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ScalarFunction::Abs => "Abs", + ScalarFunction::Acos => "Acos", + ScalarFunction::Asin => "Asin", + ScalarFunction::Atan => "Atan", + ScalarFunction::Ascii => "Ascii", + ScalarFunction::Ceil => "Ceil", + ScalarFunction::Cos => "Cos", + ScalarFunction::Digest => "Digest", + ScalarFunction::Exp => "Exp", + ScalarFunction::Floor => "Floor", + ScalarFunction::Ln => "Ln", + ScalarFunction::Log => "Log", + ScalarFunction::Log10 => "Log10", + ScalarFunction::Log2 => "Log2", + ScalarFunction::Round => "Round", + ScalarFunction::Signum => "Signum", + ScalarFunction::Sin => "Sin", + ScalarFunction::Sqrt => "Sqrt", + ScalarFunction::Tan => "Tan", + ScalarFunction::Trunc => "Trunc", + ScalarFunction::Array => "Array", + ScalarFunction::RegexpMatch => "RegexpMatch", + ScalarFunction::BitLength => "BitLength", + ScalarFunction::Btrim => "Btrim", + ScalarFunction::CharacterLength => "CharacterLength", + ScalarFunction::Chr => "Chr", + ScalarFunction::Concat => "Concat", + ScalarFunction::ConcatWithSeparator => "ConcatWithSeparator", + ScalarFunction::DatePart => "DatePart", + ScalarFunction::DateTrunc => "DateTrunc", + ScalarFunction::InitCap => "InitCap", + ScalarFunction::Left => "Left", + ScalarFunction::Lpad => "Lpad", + ScalarFunction::Lower => "Lower", + ScalarFunction::Ltrim => "Ltrim", + ScalarFunction::Md5 => "MD5", + ScalarFunction::NullIf => "NullIf", + ScalarFunction::OctetLength => "OctetLength", + ScalarFunction::Random => "Random", + ScalarFunction::RegexpReplace => "RegexpReplace", + ScalarFunction::Repeat => "Repeat", + ScalarFunction::Replace => "Replace", + ScalarFunction::Reverse => "Reverse", + ScalarFunction::Right => "Right", + ScalarFunction::Rpad => "Rpad", + ScalarFunction::Rtrim => "Rtrim", + ScalarFunction::Sha224 => "SHA224", + ScalarFunction::Sha256 => "SHA256", + ScalarFunction::Sha384 => "SHA384", + ScalarFunction::Sha512 => "SHA512", + ScalarFunction::SplitPart => "SplitPart", + ScalarFunction::StartsWith => "StartsWith", + ScalarFunction::Strpos => "Strpos", + ScalarFunction::Substr => "Substr", + ScalarFunction::ToHex => "ToHex", + ScalarFunction::ToTimestamp => "ToTimestamp", + ScalarFunction::ToTimestampMillis => "ToTimestampMillis", + ScalarFunction::ToTimestampMicros => "ToTimestampMicros", + ScalarFunction::ToTimestampSeconds => "ToTimestampSeconds", + ScalarFunction::Now => "Now", + ScalarFunction::Translate => "Translate", + ScalarFunction::Trim => "Trim", + ScalarFunction::Upper => "Upper", + ScalarFunction::Coalesce => "Coalesce", + ScalarFunction::Power => "Power", + ScalarFunction::StructFun => "StructFun", + ScalarFunction::FromUnixtime => "FromUnixtime", + ScalarFunction::Atan2 => "Atan2", + ScalarFunction::DateBin => "DateBin", + ScalarFunction::ArrowTypeof => "ArrowTypeof", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "Abs" => Some(Self::Abs), + "Acos" => Some(Self::Acos), + "Asin" => Some(Self::Asin), + "Atan" => Some(Self::Atan), + "Ascii" => Some(Self::Ascii), + "Ceil" => Some(Self::Ceil), + "Cos" => Some(Self::Cos), + "Digest" => Some(Self::Digest), + "Exp" => Some(Self::Exp), + "Floor" => Some(Self::Floor), + "Ln" => Some(Self::Ln), + "Log" => Some(Self::Log), + "Log10" => Some(Self::Log10), + "Log2" => Some(Self::Log2), + "Round" => Some(Self::Round), + "Signum" => Some(Self::Signum), + "Sin" => Some(Self::Sin), + "Sqrt" => Some(Self::Sqrt), + "Tan" => Some(Self::Tan), + "Trunc" => Some(Self::Trunc), + "Array" => Some(Self::Array), + "RegexpMatch" => Some(Self::RegexpMatch), + "BitLength" => Some(Self::BitLength), + "Btrim" => Some(Self::Btrim), + "CharacterLength" => Some(Self::CharacterLength), + "Chr" => Some(Self::Chr), + "Concat" => Some(Self::Concat), + "ConcatWithSeparator" => Some(Self::ConcatWithSeparator), + "DatePart" => Some(Self::DatePart), + "DateTrunc" => Some(Self::DateTrunc), + "InitCap" => Some(Self::InitCap), + "Left" => Some(Self::Left), + "Lpad" => Some(Self::Lpad), + "Lower" => Some(Self::Lower), + "Ltrim" => Some(Self::Ltrim), + "MD5" => Some(Self::Md5), + "NullIf" => Some(Self::NullIf), + "OctetLength" => Some(Self::OctetLength), + "Random" => Some(Self::Random), + "RegexpReplace" => Some(Self::RegexpReplace), + "Repeat" => Some(Self::Repeat), + "Replace" => Some(Self::Replace), + "Reverse" => Some(Self::Reverse), + "Right" => Some(Self::Right), + "Rpad" => Some(Self::Rpad), + "Rtrim" => Some(Self::Rtrim), + "SHA224" => Some(Self::Sha224), + "SHA256" => Some(Self::Sha256), + "SHA384" => Some(Self::Sha384), + "SHA512" => Some(Self::Sha512), + "SplitPart" => Some(Self::SplitPart), + "StartsWith" => Some(Self::StartsWith), + "Strpos" => Some(Self::Strpos), + "Substr" => Some(Self::Substr), + "ToHex" => Some(Self::ToHex), + "ToTimestamp" => Some(Self::ToTimestamp), + "ToTimestampMillis" => Some(Self::ToTimestampMillis), + "ToTimestampMicros" => Some(Self::ToTimestampMicros), + "ToTimestampSeconds" => Some(Self::ToTimestampSeconds), + "Now" => Some(Self::Now), + "Translate" => Some(Self::Translate), + "Trim" => Some(Self::Trim), + "Upper" => Some(Self::Upper), + "Coalesce" => Some(Self::Coalesce), + "Power" => Some(Self::Power), + "StructFun" => Some(Self::StructFun), + "FromUnixtime" => Some(Self::FromUnixtime), + "Atan2" => Some(Self::Atan2), + "DateBin" => Some(Self::DateBin), + "ArrowTypeof" => Some(Self::ArrowTypeof), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AggregateFunction { + Min = 0, + Max = 1, + Sum = 2, + Avg = 3, + Count = 4, + ApproxDistinct = 5, + ArrayAgg = 6, + Variance = 7, + VariancePop = 8, + Covariance = 9, + CovariancePop = 10, + Stddev = 11, + StddevPop = 12, + Correlation = 13, + ApproxPercentileCont = 14, + ApproxMedian = 15, + ApproxPercentileContWithWeight = 16, + Grouping = 17, + Median = 18, +} +impl AggregateFunction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AggregateFunction::Min => "MIN", + AggregateFunction::Max => "MAX", + AggregateFunction::Sum => "SUM", + AggregateFunction::Avg => "AVG", + AggregateFunction::Count => "COUNT", + AggregateFunction::ApproxDistinct => "APPROX_DISTINCT", + AggregateFunction::ArrayAgg => "ARRAY_AGG", + AggregateFunction::Variance => "VARIANCE", + AggregateFunction::VariancePop => "VARIANCE_POP", + AggregateFunction::Covariance => "COVARIANCE", + AggregateFunction::CovariancePop => "COVARIANCE_POP", + AggregateFunction::Stddev => "STDDEV", + AggregateFunction::StddevPop => "STDDEV_POP", + AggregateFunction::Correlation => "CORRELATION", + AggregateFunction::ApproxPercentileCont => "APPROX_PERCENTILE_CONT", + AggregateFunction::ApproxMedian => "APPROX_MEDIAN", + AggregateFunction::ApproxPercentileContWithWeight => { + "APPROX_PERCENTILE_CONT_WITH_WEIGHT" + } + AggregateFunction::Grouping => "GROUPING", + AggregateFunction::Median => "MEDIAN", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MIN" => Some(Self::Min), + "MAX" => Some(Self::Max), + "SUM" => Some(Self::Sum), + "AVG" => Some(Self::Avg), + "COUNT" => Some(Self::Count), + "APPROX_DISTINCT" => Some(Self::ApproxDistinct), + "ARRAY_AGG" => Some(Self::ArrayAgg), + "VARIANCE" => Some(Self::Variance), + "VARIANCE_POP" => Some(Self::VariancePop), + "COVARIANCE" => Some(Self::Covariance), + "COVARIANCE_POP" => Some(Self::CovariancePop), + "STDDEV" => Some(Self::Stddev), + "STDDEV_POP" => Some(Self::StddevPop), + "CORRELATION" => Some(Self::Correlation), + "APPROX_PERCENTILE_CONT" => Some(Self::ApproxPercentileCont), + "APPROX_MEDIAN" => Some(Self::ApproxMedian), + "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => { + Some(Self::ApproxPercentileContWithWeight) + } + "GROUPING" => Some(Self::Grouping), + "MEDIAN" => Some(Self::Median), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum BuiltInWindowFunction { + RowNumber = 0, + Rank = 1, + DenseRank = 2, + PercentRank = 3, + CumeDist = 4, + Ntile = 5, + Lag = 6, + Lead = 7, + FirstValue = 8, + LastValue = 9, + NthValue = 10, +} +impl BuiltInWindowFunction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + BuiltInWindowFunction::RowNumber => "ROW_NUMBER", + BuiltInWindowFunction::Rank => "RANK", + BuiltInWindowFunction::DenseRank => "DENSE_RANK", + BuiltInWindowFunction::PercentRank => "PERCENT_RANK", + BuiltInWindowFunction::CumeDist => "CUME_DIST", + BuiltInWindowFunction::Ntile => "NTILE", + BuiltInWindowFunction::Lag => "LAG", + BuiltInWindowFunction::Lead => "LEAD", + BuiltInWindowFunction::FirstValue => "FIRST_VALUE", + BuiltInWindowFunction::LastValue => "LAST_VALUE", + BuiltInWindowFunction::NthValue => "NTH_VALUE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ROW_NUMBER" => Some(Self::RowNumber), + "RANK" => Some(Self::Rank), + "DENSE_RANK" => Some(Self::DenseRank), + "PERCENT_RANK" => Some(Self::PercentRank), + "CUME_DIST" => Some(Self::CumeDist), + "NTILE" => Some(Self::Ntile), + "LAG" => Some(Self::Lag), + "LEAD" => Some(Self::Lead), + "FIRST_VALUE" => Some(Self::FirstValue), + "LAST_VALUE" => Some(Self::LastValue), + "NTH_VALUE" => Some(Self::NthValue), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum WindowFrameUnits { + Rows = 0, + Range = 1, + Groups = 2, +} +impl WindowFrameUnits { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + WindowFrameUnits::Rows => "ROWS", + WindowFrameUnits::Range => "RANGE", + WindowFrameUnits::Groups => "GROUPS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ROWS" => Some(Self::Rows), + "RANGE" => Some(Self::Range), + "GROUPS" => Some(Self::Groups), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum WindowFrameBoundType { + CurrentRow = 0, + Preceding = 1, + Following = 2, +} +impl WindowFrameBoundType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + WindowFrameBoundType::CurrentRow => "CURRENT_ROW", + WindowFrameBoundType::Preceding => "PRECEDING", + WindowFrameBoundType::Following => "FOLLOWING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CURRENT_ROW" => Some(Self::CurrentRow), + "PRECEDING" => Some(Self::Preceding), + "FOLLOWING" => Some(Self::Following), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum DateUnit { + Day = 0, + DateMillisecond = 1, +} +impl DateUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DateUnit::Day => "Day", + DateUnit::DateMillisecond => "DateMillisecond", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "Day" => Some(Self::Day), + "DateMillisecond" => Some(Self::DateMillisecond), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum TimeUnit { + Second = 0, + TimeMillisecond = 1, + Microsecond = 2, + Nanosecond = 3, +} +impl TimeUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TimeUnit::Second => "Second", + TimeUnit::TimeMillisecond => "TimeMillisecond", + TimeUnit::Microsecond => "Microsecond", + TimeUnit::Nanosecond => "Nanosecond", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "Second" => Some(Self::Second), + "TimeMillisecond" => Some(Self::TimeMillisecond), + "Microsecond" => Some(Self::Microsecond), + "Nanosecond" => Some(Self::Nanosecond), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum IntervalUnit { + YearMonth = 0, + DayTime = 1, + MonthDayNano = 2, +} +impl IntervalUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + IntervalUnit::YearMonth => "YearMonth", + IntervalUnit::DayTime => "DayTime", + IntervalUnit::MonthDayNano => "MonthDayNano", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "YearMonth" => Some(Self::YearMonth), + "DayTime" => Some(Self::DayTime), + "MonthDayNano" => Some(Self::MonthDayNano), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum UnionMode { + Sparse = 0, + Dense = 1, +} +impl UnionMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + UnionMode::Sparse => "sparse", + UnionMode::Dense => "dense", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "sparse" => Some(Self::Sparse), + "dense" => Some(Self::Dense), + _ => None, + } + } +} +/// Contains all valid datafusion scalar type except for +/// List +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum PrimitiveScalarType { + /// arrow::Type::BOOL + Bool = 0, + /// arrow::Type::UINT8 + Uint8 = 1, + /// arrow::Type::INT8 + Int8 = 2, + /// represents arrow::Type fields in src/arrow/type.h + Uint16 = 3, + Int16 = 4, + Uint32 = 5, + Int32 = 6, + Uint64 = 7, + Int64 = 8, + Float32 = 9, + Float64 = 10, + Utf8 = 11, + LargeUtf8 = 12, + Date32 = 13, + TimeMicrosecond = 14, + TimeNanosecond = 15, + Null = 16, + Decimal128 = 17, + Date64 = 20, + TimeSecond = 21, + TimeMillisecond = 22, + IntervalYearmonth = 23, + IntervalDaytime = 24, +} +impl PrimitiveScalarType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + PrimitiveScalarType::Bool => "BOOL", + PrimitiveScalarType::Uint8 => "UINT8", + PrimitiveScalarType::Int8 => "INT8", + PrimitiveScalarType::Uint16 => "UINT16", + PrimitiveScalarType::Int16 => "INT16", + PrimitiveScalarType::Uint32 => "UINT32", + PrimitiveScalarType::Int32 => "INT32", + PrimitiveScalarType::Uint64 => "UINT64", + PrimitiveScalarType::Int64 => "INT64", + PrimitiveScalarType::Float32 => "FLOAT32", + PrimitiveScalarType::Float64 => "FLOAT64", + PrimitiveScalarType::Utf8 => "UTF8", + PrimitiveScalarType::LargeUtf8 => "LARGE_UTF8", + PrimitiveScalarType::Date32 => "DATE32", + PrimitiveScalarType::TimeMicrosecond => "TIME_MICROSECOND", + PrimitiveScalarType::TimeNanosecond => "TIME_NANOSECOND", + PrimitiveScalarType::Null => "NULL", + PrimitiveScalarType::Decimal128 => "DECIMAL128", + PrimitiveScalarType::Date64 => "DATE64", + PrimitiveScalarType::TimeSecond => "TIME_SECOND", + PrimitiveScalarType::TimeMillisecond => "TIME_MILLISECOND", + PrimitiveScalarType::IntervalYearmonth => "INTERVAL_YEARMONTH", + PrimitiveScalarType::IntervalDaytime => "INTERVAL_DAYTIME", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "BOOL" => Some(Self::Bool), + "UINT8" => Some(Self::Uint8), + "INT8" => Some(Self::Int8), + "UINT16" => Some(Self::Uint16), + "INT16" => Some(Self::Int16), + "UINT32" => Some(Self::Uint32), + "INT32" => Some(Self::Int32), + "UINT64" => Some(Self::Uint64), + "INT64" => Some(Self::Int64), + "FLOAT32" => Some(Self::Float32), + "FLOAT64" => Some(Self::Float64), + "UTF8" => Some(Self::Utf8), + "LARGE_UTF8" => Some(Self::LargeUtf8), + "DATE32" => Some(Self::Date32), + "TIME_MICROSECOND" => Some(Self::TimeMicrosecond), + "TIME_NANOSECOND" => Some(Self::TimeNanosecond), + "NULL" => Some(Self::Null), + "DECIMAL128" => Some(Self::Decimal128), + "DATE64" => Some(Self::Date64), + "TIME_SECOND" => Some(Self::TimeSecond), + "TIME_MILLISECOND" => Some(Self::TimeMillisecond), + "INTERVAL_YEARMONTH" => Some(Self::IntervalYearmonth), + "INTERVAL_DAYTIME" => Some(Self::IntervalDaytime), + _ => None, + } + } +} +impl serde::Serialize for AggregateExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.aggr_function != 0 { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if self.distinct { + len += 1; + } + if self.filter.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExprNode", len)?; + if self.aggr_function != 0 { + let v = AggregateFunction::from_i32(self.aggr_function) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.aggr_function)))?; + struct_ser.serialize_field("aggrFunction", &v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if self.distinct { + struct_ser.serialize_field("distinct", &self.distinct)?; + } + if let Some(v) = self.filter.as_ref() { + struct_ser.serialize_field("filter", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AggregateExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "aggrFunction", + "expr", + "distinct", + "filter", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AggrFunction, + Expr, + Distinct, + Filter, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "aggrFunction" => Ok(GeneratedField::AggrFunction), + "expr" => Ok(GeneratedField::Expr), + "distinct" => Ok(GeneratedField::Distinct), + "filter" => Ok(GeneratedField::Filter), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AggregateExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AggregateExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut aggr_function__ = None; + let mut expr__ = None; + let mut distinct__ = None; + let mut filter__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::AggrFunction => { + if aggr_function__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrFunction")); + } + aggr_function__ = Some(map.next_value::()? as i32); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Distinct => { + if distinct__.is_some() { + return Err(serde::de::Error::duplicate_field("distinct")); + } + distinct__ = Some(map.next_value()?); + } + GeneratedField::Filter => { + if filter__.is_some() { + return Err(serde::de::Error::duplicate_field("filter")); + } + filter__ = Some(map.next_value()?); + } + } + } + Ok(AggregateExprNode { + aggr_function: aggr_function__.unwrap_or_default(), + expr: expr__.unwrap_or_default(), + distinct: distinct__.unwrap_or_default(), + filter: filter__, + }) + } + } + deserializer.deserialize_struct("datafusion.AggregateExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AggregateFunction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Min => "MIN", + Self::Max => "MAX", + Self::Sum => "SUM", + Self::Avg => "AVG", + Self::Count => "COUNT", + Self::ApproxDistinct => "APPROX_DISTINCT", + Self::ArrayAgg => "ARRAY_AGG", + Self::Variance => "VARIANCE", + Self::VariancePop => "VARIANCE_POP", + Self::Covariance => "COVARIANCE", + Self::CovariancePop => "COVARIANCE_POP", + Self::Stddev => "STDDEV", + Self::StddevPop => "STDDEV_POP", + Self::Correlation => "CORRELATION", + Self::ApproxPercentileCont => "APPROX_PERCENTILE_CONT", + Self::ApproxMedian => "APPROX_MEDIAN", + Self::ApproxPercentileContWithWeight => "APPROX_PERCENTILE_CONT_WITH_WEIGHT", + Self::Grouping => "GROUPING", + Self::Median => "MEDIAN", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for AggregateFunction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "MIN", + "MAX", + "SUM", + "AVG", + "COUNT", + "APPROX_DISTINCT", + "ARRAY_AGG", + "VARIANCE", + "VARIANCE_POP", + "COVARIANCE", + "COVARIANCE_POP", + "STDDEV", + "STDDEV_POP", + "CORRELATION", + "APPROX_PERCENTILE_CONT", + "APPROX_MEDIAN", + "APPROX_PERCENTILE_CONT_WITH_WEIGHT", + "GROUPING", + "MEDIAN", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AggregateFunction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(AggregateFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(AggregateFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "MIN" => Ok(AggregateFunction::Min), + "MAX" => Ok(AggregateFunction::Max), + "SUM" => Ok(AggregateFunction::Sum), + "AVG" => Ok(AggregateFunction::Avg), + "COUNT" => Ok(AggregateFunction::Count), + "APPROX_DISTINCT" => Ok(AggregateFunction::ApproxDistinct), + "ARRAY_AGG" => Ok(AggregateFunction::ArrayAgg), + "VARIANCE" => Ok(AggregateFunction::Variance), + "VARIANCE_POP" => Ok(AggregateFunction::VariancePop), + "COVARIANCE" => Ok(AggregateFunction::Covariance), + "COVARIANCE_POP" => Ok(AggregateFunction::CovariancePop), + "STDDEV" => Ok(AggregateFunction::Stddev), + "STDDEV_POP" => Ok(AggregateFunction::StddevPop), + "CORRELATION" => Ok(AggregateFunction::Correlation), + "APPROX_PERCENTILE_CONT" => Ok(AggregateFunction::ApproxPercentileCont), + "APPROX_MEDIAN" => Ok(AggregateFunction::ApproxMedian), + "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => Ok(AggregateFunction::ApproxPercentileContWithWeight), + "GROUPING" => Ok(AggregateFunction::Grouping), + "MEDIAN" => Ok(AggregateFunction::Median), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for AggregateNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.group_expr.is_empty() { + len += 1; + } + if !self.aggr_expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.AggregateNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.group_expr.is_empty() { + struct_ser.serialize_field("groupExpr", &self.group_expr)?; + } + if !self.aggr_expr.is_empty() { + struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AggregateNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "groupExpr", + "aggrExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + GroupExpr, + AggrExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "groupExpr" => Ok(GeneratedField::GroupExpr), + "aggrExpr" => Ok(GeneratedField::AggrExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AggregateNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AggregateNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut group_expr__ = None; + let mut aggr_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::GroupExpr => { + if group_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("groupExpr")); + } + group_expr__ = Some(map.next_value()?); + } + GeneratedField::AggrExpr => { + if aggr_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrExpr")); + } + aggr_expr__ = Some(map.next_value()?); + } + } + } + Ok(AggregateNode { + input: input__, + group_expr: group_expr__.unwrap_or_default(), + aggr_expr: aggr_expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.AggregateNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AggregateUdfExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.fun_name.is_empty() { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + if self.filter.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.AggregateUDFExprNode", len)?; + if !self.fun_name.is_empty() { + struct_ser.serialize_field("funName", &self.fun_name)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + if let Some(v) = self.filter.as_ref() { + struct_ser.serialize_field("filter", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "funName", + "args", + "filter", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FunName, + Args, + Filter, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "funName" => Ok(GeneratedField::FunName), + "args" => Ok(GeneratedField::Args), + "filter" => Ok(GeneratedField::Filter), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AggregateUdfExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AggregateUDFExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fun_name__ = None; + let mut args__ = None; + let mut filter__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FunName => { + if fun_name__.is_some() { + return Err(serde::de::Error::duplicate_field("funName")); + } + fun_name__ = Some(map.next_value()?); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + GeneratedField::Filter => { + if filter__.is_some() { + return Err(serde::de::Error::duplicate_field("filter")); + } + filter__ = Some(map.next_value()?); + } + } + } + Ok(AggregateUdfExprNode { + fun_name: fun_name__.unwrap_or_default(), + args: args__.unwrap_or_default(), + filter: filter__, + }) + } + } + deserializer.deserialize_struct("datafusion.AggregateUDFExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AliasNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.alias.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.AliasNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.alias.is_empty() { + struct_ser.serialize_field("alias", &self.alias)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AliasNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "alias", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Alias, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "alias" => Ok(GeneratedField::Alias), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AliasNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AliasNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut alias__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Alias => { + if alias__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + alias__ = Some(map.next_value()?); + } + } + } + Ok(AliasNode { + expr: expr__, + alias: alias__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.AliasNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AnalyzeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.verbose { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzeNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.verbose { + struct_ser.serialize_field("verbose", &self.verbose)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AnalyzeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "verbose", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Verbose, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "verbose" => Ok(GeneratedField::Verbose), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AnalyzeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AnalyzeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut verbose__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Verbose => { + if verbose__.is_some() { + return Err(serde::de::Error::duplicate_field("verbose")); + } + verbose__ = Some(map.next_value()?); + } + } + } + Ok(AnalyzeNode { + input: input__, + verbose: verbose__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.AnalyzeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ArrowType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.arrow_type_enum.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ArrowType", len)?; + if let Some(v) = self.arrow_type_enum.as_ref() { + match v { + arrow_type::ArrowTypeEnum::None(v) => { + struct_ser.serialize_field("NONE", v)?; + } + arrow_type::ArrowTypeEnum::Bool(v) => { + struct_ser.serialize_field("BOOL", v)?; + } + arrow_type::ArrowTypeEnum::Uint8(v) => { + struct_ser.serialize_field("UINT8", v)?; + } + arrow_type::ArrowTypeEnum::Int8(v) => { + struct_ser.serialize_field("INT8", v)?; + } + arrow_type::ArrowTypeEnum::Uint16(v) => { + struct_ser.serialize_field("UINT16", v)?; + } + arrow_type::ArrowTypeEnum::Int16(v) => { + struct_ser.serialize_field("INT16", v)?; + } + arrow_type::ArrowTypeEnum::Uint32(v) => { + struct_ser.serialize_field("UINT32", v)?; + } + arrow_type::ArrowTypeEnum::Int32(v) => { + struct_ser.serialize_field("INT32", v)?; + } + arrow_type::ArrowTypeEnum::Uint64(v) => { + struct_ser.serialize_field("UINT64", v)?; + } + arrow_type::ArrowTypeEnum::Int64(v) => { + struct_ser.serialize_field("INT64", v)?; + } + arrow_type::ArrowTypeEnum::Float16(v) => { + struct_ser.serialize_field("FLOAT16", v)?; + } + arrow_type::ArrowTypeEnum::Float32(v) => { + struct_ser.serialize_field("FLOAT32", v)?; + } + arrow_type::ArrowTypeEnum::Float64(v) => { + struct_ser.serialize_field("FLOAT64", v)?; + } + arrow_type::ArrowTypeEnum::Utf8(v) => { + struct_ser.serialize_field("UTF8", v)?; + } + arrow_type::ArrowTypeEnum::LargeUtf8(v) => { + struct_ser.serialize_field("LARGEUTF8", v)?; + } + arrow_type::ArrowTypeEnum::Binary(v) => { + struct_ser.serialize_field("BINARY", v)?; + } + arrow_type::ArrowTypeEnum::FixedSizeBinary(v) => { + struct_ser.serialize_field("FIXEDSIZEBINARY", v)?; + } + arrow_type::ArrowTypeEnum::LargeBinary(v) => { + struct_ser.serialize_field("LARGEBINARY", v)?; + } + arrow_type::ArrowTypeEnum::Date32(v) => { + struct_ser.serialize_field("DATE32", v)?; + } + arrow_type::ArrowTypeEnum::Date64(v) => { + struct_ser.serialize_field("DATE64", v)?; + } + arrow_type::ArrowTypeEnum::Duration(v) => { + let v = TimeUnit::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("DURATION", &v)?; + } + arrow_type::ArrowTypeEnum::Timestamp(v) => { + struct_ser.serialize_field("TIMESTAMP", v)?; + } + arrow_type::ArrowTypeEnum::Time32(v) => { + let v = TimeUnit::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("TIME32", &v)?; + } + arrow_type::ArrowTypeEnum::Time64(v) => { + let v = TimeUnit::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("TIME64", &v)?; + } + arrow_type::ArrowTypeEnum::Interval(v) => { + let v = IntervalUnit::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("INTERVAL", &v)?; + } + arrow_type::ArrowTypeEnum::Decimal(v) => { + struct_ser.serialize_field("DECIMAL", v)?; + } + arrow_type::ArrowTypeEnum::List(v) => { + struct_ser.serialize_field("LIST", v)?; + } + arrow_type::ArrowTypeEnum::LargeList(v) => { + struct_ser.serialize_field("LARGELIST", v)?; + } + arrow_type::ArrowTypeEnum::FixedSizeList(v) => { + struct_ser.serialize_field("FIXEDSIZELIST", v)?; + } + arrow_type::ArrowTypeEnum::Struct(v) => { + struct_ser.serialize_field("STRUCT", v)?; + } + arrow_type::ArrowTypeEnum::Union(v) => { + struct_ser.serialize_field("UNION", v)?; + } + arrow_type::ArrowTypeEnum::Dictionary(v) => { + struct_ser.serialize_field("DICTIONARY", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ArrowType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "NONE", + "BOOL", + "UINT8", + "INT8", + "UINT16", + "INT16", + "UINT32", + "INT32", + "UINT64", + "INT64", + "FLOAT16", + "FLOAT32", + "FLOAT64", + "UTF8", + "LARGEUTF8", + "BINARY", + "FIXEDSIZEBINARY", + "LARGEBINARY", + "DATE32", + "DATE64", + "DURATION", + "TIMESTAMP", + "TIME32", + "TIME64", + "INTERVAL", + "DECIMAL", + "LIST", + "LARGELIST", + "FIXEDSIZELIST", + "STRUCT", + "UNION", + "DICTIONARY", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + None, + Bool, + Uint8, + Int8, + Uint16, + Int16, + Uint32, + Int32, + Uint64, + Int64, + Float16, + Float32, + Float64, + Utf8, + LargeUtf8, + Binary, + FixedSizeBinary, + LargeBinary, + Date32, + Date64, + Duration, + Timestamp, + Time32, + Time64, + Interval, + Decimal, + List, + LargeList, + FixedSizeList, + Struct, + Union, + Dictionary, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "NONE" => Ok(GeneratedField::None), + "BOOL" => Ok(GeneratedField::Bool), + "UINT8" => Ok(GeneratedField::Uint8), + "INT8" => Ok(GeneratedField::Int8), + "UINT16" => Ok(GeneratedField::Uint16), + "INT16" => Ok(GeneratedField::Int16), + "UINT32" => Ok(GeneratedField::Uint32), + "INT32" => Ok(GeneratedField::Int32), + "UINT64" => Ok(GeneratedField::Uint64), + "INT64" => Ok(GeneratedField::Int64), + "FLOAT16" => Ok(GeneratedField::Float16), + "FLOAT32" => Ok(GeneratedField::Float32), + "FLOAT64" => Ok(GeneratedField::Float64), + "UTF8" => Ok(GeneratedField::Utf8), + "LARGEUTF8" => Ok(GeneratedField::LargeUtf8), + "BINARY" => Ok(GeneratedField::Binary), + "FIXEDSIZEBINARY" => Ok(GeneratedField::FixedSizeBinary), + "LARGEBINARY" => Ok(GeneratedField::LargeBinary), + "DATE32" => Ok(GeneratedField::Date32), + "DATE64" => Ok(GeneratedField::Date64), + "DURATION" => Ok(GeneratedField::Duration), + "TIMESTAMP" => Ok(GeneratedField::Timestamp), + "TIME32" => Ok(GeneratedField::Time32), + "TIME64" => Ok(GeneratedField::Time64), + "INTERVAL" => Ok(GeneratedField::Interval), + "DECIMAL" => Ok(GeneratedField::Decimal), + "LIST" => Ok(GeneratedField::List), + "LARGELIST" => Ok(GeneratedField::LargeList), + "FIXEDSIZELIST" => Ok(GeneratedField::FixedSizeList), + "STRUCT" => Ok(GeneratedField::Struct), + "UNION" => Ok(GeneratedField::Union), + "DICTIONARY" => Ok(GeneratedField::Dictionary), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ArrowType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ArrowType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut arrow_type_enum__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::None => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("NONE")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::None(map.next_value()?)); + } + GeneratedField::Bool => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("BOOL")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Bool(map.next_value()?)); + } + GeneratedField::Uint8 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("UINT8")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint8(map.next_value()?)); + } + GeneratedField::Int8 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("INT8")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int8(map.next_value()?)); + } + GeneratedField::Uint16 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("UINT16")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint16(map.next_value()?)); + } + GeneratedField::Int16 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("INT16")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int16(map.next_value()?)); + } + GeneratedField::Uint32 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("UINT32")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint32(map.next_value()?)); + } + GeneratedField::Int32 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("INT32")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int32(map.next_value()?)); + } + GeneratedField::Uint64 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("UINT64")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint64(map.next_value()?)); + } + GeneratedField::Int64 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("INT64")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int64(map.next_value()?)); + } + GeneratedField::Float16 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FLOAT16")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float16(map.next_value()?)); + } + GeneratedField::Float32 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FLOAT32")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float32(map.next_value()?)); + } + GeneratedField::Float64 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FLOAT64")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float64(map.next_value()?)); + } + GeneratedField::Utf8 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("UTF8")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Utf8(map.next_value()?)); + } + GeneratedField::LargeUtf8 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("LARGEUTF8")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeUtf8(map.next_value()?)); + } + GeneratedField::Binary => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("BINARY")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Binary(map.next_value()?)); + } + GeneratedField::FixedSizeBinary => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FIXEDSIZEBINARY")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::FixedSizeBinary( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::LargeBinary => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("LARGEBINARY")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeBinary(map.next_value()?)); + } + GeneratedField::Date32 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("DATE32")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Date32(map.next_value()?)); + } + GeneratedField::Date64 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("DATE64")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Date64(map.next_value()?)); + } + GeneratedField::Duration => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("DURATION")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Duration(map.next_value::()? as i32)); + } + GeneratedField::Timestamp => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("TIMESTAMP")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Timestamp(map.next_value()?)); + } + GeneratedField::Time32 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("TIME32")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Time32(map.next_value::()? as i32)); + } + GeneratedField::Time64 => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("TIME64")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Time64(map.next_value::()? as i32)); + } + GeneratedField::Interval => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("INTERVAL")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Interval(map.next_value::()? as i32)); + } + GeneratedField::Decimal => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("DECIMAL")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Decimal(map.next_value()?)); + } + GeneratedField::List => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("LIST")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::List(map.next_value()?)); + } + GeneratedField::LargeList => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("LARGELIST")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeList(map.next_value()?)); + } + GeneratedField::FixedSizeList => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FIXEDSIZELIST")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::FixedSizeList(map.next_value()?)); + } + GeneratedField::Struct => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("STRUCT")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Struct(map.next_value()?)); + } + GeneratedField::Union => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("UNION")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Union(map.next_value()?)); + } + GeneratedField::Dictionary => { + if arrow_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("DICTIONARY")); + } + arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Dictionary(map.next_value()?)); + } + } + } + Ok(ArrowType { + arrow_type_enum: arrow_type_enum__, + }) + } + } + deserializer.deserialize_struct("datafusion.ArrowType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AvroFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("datafusion.AvroFormat", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AvroFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AvroFormat; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AvroFormat") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(AvroFormat { + }) + } + } + deserializer.deserialize_struct("datafusion.AvroFormat", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BetweenNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.negated { + len += 1; + } + if self.low.is_some() { + len += 1; + } + if self.high.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.BetweenNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.low.as_ref() { + struct_ser.serialize_field("low", v)?; + } + if let Some(v) = self.high.as_ref() { + struct_ser.serialize_field("high", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BetweenNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "negated", + "low", + "high", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Negated, + Low, + High, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "negated" => Ok(GeneratedField::Negated), + "low" => Ok(GeneratedField::Low), + "high" => Ok(GeneratedField::High), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BetweenNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.BetweenNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut negated__ = None; + let mut low__ = None; + let mut high__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + GeneratedField::Low => { + if low__.is_some() { + return Err(serde::de::Error::duplicate_field("low")); + } + low__ = Some(map.next_value()?); + } + GeneratedField::High => { + if high__.is_some() { + return Err(serde::de::Error::duplicate_field("high")); + } + high__ = Some(map.next_value()?); + } + } + } + Ok(BetweenNode { + expr: expr__, + negated: negated__.unwrap_or_default(), + low: low__, + high: high__, + }) + } + } + deserializer.deserialize_struct("datafusion.BetweenNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BinaryExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.l.is_some() { + len += 1; + } + if self.r.is_some() { + len += 1; + } + if !self.op.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.BinaryExprNode", len)?; + if let Some(v) = self.l.as_ref() { + struct_ser.serialize_field("l", v)?; + } + if let Some(v) = self.r.as_ref() { + struct_ser.serialize_field("r", v)?; + } + if !self.op.is_empty() { + struct_ser.serialize_field("op", &self.op)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BinaryExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "l", + "r", + "op", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + L, + R, + Op, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "l" => Ok(GeneratedField::L), + "r" => Ok(GeneratedField::R), + "op" => Ok(GeneratedField::Op), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BinaryExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.BinaryExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut l__ = None; + let mut r__ = None; + let mut op__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::L => { + if l__.is_some() { + return Err(serde::de::Error::duplicate_field("l")); + } + l__ = Some(map.next_value()?); + } + GeneratedField::R => { + if r__.is_some() { + return Err(serde::de::Error::duplicate_field("r")); + } + r__ = Some(map.next_value()?); + } + GeneratedField::Op => { + if op__.is_some() { + return Err(serde::de::Error::duplicate_field("op")); + } + op__ = Some(map.next_value()?); + } + } + } + Ok(BinaryExprNode { + l: l__, + r: r__, + op: op__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.BinaryExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BuiltInWindowFunction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::RowNumber => "ROW_NUMBER", + Self::Rank => "RANK", + Self::DenseRank => "DENSE_RANK", + Self::PercentRank => "PERCENT_RANK", + Self::CumeDist => "CUME_DIST", + Self::Ntile => "NTILE", + Self::Lag => "LAG", + Self::Lead => "LEAD", + Self::FirstValue => "FIRST_VALUE", + Self::LastValue => "LAST_VALUE", + Self::NthValue => "NTH_VALUE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for BuiltInWindowFunction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ROW_NUMBER", + "RANK", + "DENSE_RANK", + "PERCENT_RANK", + "CUME_DIST", + "NTILE", + "LAG", + "LEAD", + "FIRST_VALUE", + "LAST_VALUE", + "NTH_VALUE", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BuiltInWindowFunction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(BuiltInWindowFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(BuiltInWindowFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ROW_NUMBER" => Ok(BuiltInWindowFunction::RowNumber), + "RANK" => Ok(BuiltInWindowFunction::Rank), + "DENSE_RANK" => Ok(BuiltInWindowFunction::DenseRank), + "PERCENT_RANK" => Ok(BuiltInWindowFunction::PercentRank), + "CUME_DIST" => Ok(BuiltInWindowFunction::CumeDist), + "NTILE" => Ok(BuiltInWindowFunction::Ntile), + "LAG" => Ok(BuiltInWindowFunction::Lag), + "LEAD" => Ok(BuiltInWindowFunction::Lead), + "FIRST_VALUE" => Ok(BuiltInWindowFunction::FirstValue), + "LAST_VALUE" => Ok(BuiltInWindowFunction::LastValue), + "NTH_VALUE" => Ok(BuiltInWindowFunction::NthValue), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for CaseNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.when_then_expr.is_empty() { + len += 1; + } + if self.else_expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CaseNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.when_then_expr.is_empty() { + struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?; + } + if let Some(v) = self.else_expr.as_ref() { + struct_ser.serialize_field("elseExpr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CaseNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "whenThenExpr", + "elseExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + WhenThenExpr, + ElseExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "whenThenExpr" => Ok(GeneratedField::WhenThenExpr), + "elseExpr" => Ok(GeneratedField::ElseExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CaseNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CaseNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut when_then_expr__ = None; + let mut else_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::WhenThenExpr => { + if when_then_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("whenThenExpr")); + } + when_then_expr__ = Some(map.next_value()?); + } + GeneratedField::ElseExpr => { + if else_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("elseExpr")); + } + else_expr__ = Some(map.next_value()?); + } + } + } + Ok(CaseNode { + expr: expr__, + when_then_expr: when_then_expr__.unwrap_or_default(), + else_expr: else_expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.CaseNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CastNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.arrow_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CastNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CastNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "arrowType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + ArrowType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "arrowType" => Ok(GeneratedField::ArrowType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CastNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CastNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut arrow_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::ArrowType => { + if arrow_type__.is_some() { + return Err(serde::de::Error::duplicate_field("arrowType")); + } + arrow_type__ = Some(map.next_value()?); + } + } + } + Ok(CastNode { + expr: expr__, + arrow_type: arrow_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.CastNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Column { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.relation.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Column", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.relation.as_ref() { + struct_ser.serialize_field("relation", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Column { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "relation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Relation, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "relation" => Ok(GeneratedField::Relation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Column; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Column") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut relation__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Relation => { + if relation__.is_some() { + return Err(serde::de::Error::duplicate_field("relation")); + } + relation__ = Some(map.next_value()?); + } + } + } + Ok(Column { + name: name__.unwrap_or_default(), + relation: relation__, + }) + } + } + deserializer.deserialize_struct("datafusion.Column", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ColumnRelation { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.relation.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ColumnRelation", len)?; + if !self.relation.is_empty() { + struct_ser.serialize_field("relation", &self.relation)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ColumnRelation { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "relation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Relation, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "relation" => Ok(GeneratedField::Relation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ColumnRelation; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ColumnRelation") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut relation__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Relation => { + if relation__.is_some() { + return Err(serde::de::Error::duplicate_field("relation")); + } + relation__ = Some(map.next_value()?); + } + } + } + Ok(ColumnRelation { + relation: relation__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ColumnRelation", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CreateCatalogNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.catalog_name.is_empty() { + len += 1; + } + if self.if_not_exists { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogNode", len)?; + if !self.catalog_name.is_empty() { + struct_ser.serialize_field("catalogName", &self.catalog_name)?; + } + if self.if_not_exists { + struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateCatalogNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "catalogName", + "ifNotExists", + "schema", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CatalogName, + IfNotExists, + Schema, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "catalogName" => Ok(GeneratedField::CatalogName), + "ifNotExists" => Ok(GeneratedField::IfNotExists), + "schema" => Ok(GeneratedField::Schema), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateCatalogNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CreateCatalogNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut catalog_name__ = None; + let mut if_not_exists__ = None; + let mut schema__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::CatalogName => { + if catalog_name__.is_some() { + return Err(serde::de::Error::duplicate_field("catalogName")); + } + catalog_name__ = Some(map.next_value()?); + } + GeneratedField::IfNotExists => { + if if_not_exists__.is_some() { + return Err(serde::de::Error::duplicate_field("ifNotExists")); + } + if_not_exists__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = Some(map.next_value()?); + } + } + } + Ok(CreateCatalogNode { + catalog_name: catalog_name__.unwrap_or_default(), + if_not_exists: if_not_exists__.unwrap_or_default(), + schema: schema__, + }) + } + } + deserializer.deserialize_struct("datafusion.CreateCatalogNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CreateCatalogSchemaNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.schema_name.is_empty() { + len += 1; + } + if self.if_not_exists { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogSchemaNode", len)?; + if !self.schema_name.is_empty() { + struct_ser.serialize_field("schemaName", &self.schema_name)?; + } + if self.if_not_exists { + struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "schemaName", + "ifNotExists", + "schema", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SchemaName, + IfNotExists, + Schema, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "schemaName" => Ok(GeneratedField::SchemaName), + "ifNotExists" => Ok(GeneratedField::IfNotExists), + "schema" => Ok(GeneratedField::Schema), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateCatalogSchemaNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CreateCatalogSchemaNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut schema_name__ = None; + let mut if_not_exists__ = None; + let mut schema__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::SchemaName => { + if schema_name__.is_some() { + return Err(serde::de::Error::duplicate_field("schemaName")); + } + schema_name__ = Some(map.next_value()?); + } + GeneratedField::IfNotExists => { + if if_not_exists__.is_some() { + return Err(serde::de::Error::duplicate_field("ifNotExists")); + } + if_not_exists__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = Some(map.next_value()?); + } + } + } + Ok(CreateCatalogSchemaNode { + schema_name: schema_name__.unwrap_or_default(), + if_not_exists: if_not_exists__.unwrap_or_default(), + schema: schema__, + }) + } + } + deserializer.deserialize_struct("datafusion.CreateCatalogSchemaNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CreateExternalTableNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if !self.location.is_empty() { + len += 1; + } + if !self.file_type.is_empty() { + len += 1; + } + if self.has_header { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + if !self.table_partition_cols.is_empty() { + len += 1; + } + if self.if_not_exists { + len += 1; + } + if !self.delimiter.is_empty() { + len += 1; + } + if !self.definition.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.location.is_empty() { + struct_ser.serialize_field("location", &self.location)?; + } + if !self.file_type.is_empty() { + struct_ser.serialize_field("fileType", &self.file_type)?; + } + if self.has_header { + struct_ser.serialize_field("hasHeader", &self.has_header)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if !self.table_partition_cols.is_empty() { + struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; + } + if self.if_not_exists { + struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + } + if !self.delimiter.is_empty() { + struct_ser.serialize_field("delimiter", &self.delimiter)?; + } + if !self.definition.is_empty() { + struct_ser.serialize_field("definition", &self.definition)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateExternalTableNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "location", + "fileType", + "hasHeader", + "schema", + "tablePartitionCols", + "ifNotExists", + "delimiter", + "definition", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Location, + FileType, + HasHeader, + Schema, + TablePartitionCols, + IfNotExists, + Delimiter, + Definition, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "location" => Ok(GeneratedField::Location), + "fileType" => Ok(GeneratedField::FileType), + "hasHeader" => Ok(GeneratedField::HasHeader), + "schema" => Ok(GeneratedField::Schema), + "tablePartitionCols" => Ok(GeneratedField::TablePartitionCols), + "ifNotExists" => Ok(GeneratedField::IfNotExists), + "delimiter" => Ok(GeneratedField::Delimiter), + "definition" => Ok(GeneratedField::Definition), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateExternalTableNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CreateExternalTableNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut location__ = None; + let mut file_type__ = None; + let mut has_header__ = None; + let mut schema__ = None; + let mut table_partition_cols__ = None; + let mut if_not_exists__ = None; + let mut delimiter__ = None; + let mut definition__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Location => { + if location__.is_some() { + return Err(serde::de::Error::duplicate_field("location")); + } + location__ = Some(map.next_value()?); + } + GeneratedField::FileType => { + if file_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fileType")); + } + file_type__ = Some(map.next_value()?); + } + GeneratedField::HasHeader => { + if has_header__.is_some() { + return Err(serde::de::Error::duplicate_field("hasHeader")); + } + has_header__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = Some(map.next_value()?); + } + GeneratedField::TablePartitionCols => { + if table_partition_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("tablePartitionCols")); + } + table_partition_cols__ = Some(map.next_value()?); + } + GeneratedField::IfNotExists => { + if if_not_exists__.is_some() { + return Err(serde::de::Error::duplicate_field("ifNotExists")); + } + if_not_exists__ = Some(map.next_value()?); + } + GeneratedField::Delimiter => { + if delimiter__.is_some() { + return Err(serde::de::Error::duplicate_field("delimiter")); + } + delimiter__ = Some(map.next_value()?); + } + GeneratedField::Definition => { + if definition__.is_some() { + return Err(serde::de::Error::duplicate_field("definition")); + } + definition__ = Some(map.next_value()?); + } + } + } + Ok(CreateExternalTableNode { + name: name__.unwrap_or_default(), + location: location__.unwrap_or_default(), + file_type: file_type__.unwrap_or_default(), + has_header: has_header__.unwrap_or_default(), + schema: schema__, + table_partition_cols: table_partition_cols__.unwrap_or_default(), + if_not_exists: if_not_exists__.unwrap_or_default(), + delimiter: delimiter__.unwrap_or_default(), + definition: definition__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.CreateExternalTableNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CreateViewNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.input.is_some() { + len += 1; + } + if self.or_replace { + len += 1; + } + if !self.definition.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CreateViewNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.or_replace { + struct_ser.serialize_field("orReplace", &self.or_replace)?; + } + if !self.definition.is_empty() { + struct_ser.serialize_field("definition", &self.definition)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateViewNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "input", + "orReplace", + "definition", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Input, + OrReplace, + Definition, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "input" => Ok(GeneratedField::Input), + "orReplace" => Ok(GeneratedField::OrReplace), + "definition" => Ok(GeneratedField::Definition), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateViewNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CreateViewNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut input__ = None; + let mut or_replace__ = None; + let mut definition__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::OrReplace => { + if or_replace__.is_some() { + return Err(serde::de::Error::duplicate_field("orReplace")); + } + or_replace__ = Some(map.next_value()?); + } + GeneratedField::Definition => { + if definition__.is_some() { + return Err(serde::de::Error::duplicate_field("definition")); + } + definition__ = Some(map.next_value()?); + } + } + } + Ok(CreateViewNode { + name: name__.unwrap_or_default(), + input: input__, + or_replace: or_replace__.unwrap_or_default(), + definition: definition__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.CreateViewNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CrossJoinNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.left.is_some() { + len += 1; + } + if self.right.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinNode", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; + } + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CrossJoinNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "left", + "right", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Left, + Right, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CrossJoinNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CrossJoinNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut left__ = None; + let mut right__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); + } + left__ = Some(map.next_value()?); + } + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); + } + right__ = Some(map.next_value()?); + } + } + } + Ok(CrossJoinNode { + left: left__, + right: right__, + }) + } + } + deserializer.deserialize_struct("datafusion.CrossJoinNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CsvFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.has_header { + len += 1; + } + if !self.delimiter.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CsvFormat", len)?; + if self.has_header { + struct_ser.serialize_field("hasHeader", &self.has_header)?; + } + if !self.delimiter.is_empty() { + struct_ser.serialize_field("delimiter", &self.delimiter)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CsvFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hasHeader", + "delimiter", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HasHeader, + Delimiter, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "hasHeader" => Ok(GeneratedField::HasHeader), + "delimiter" => Ok(GeneratedField::Delimiter), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CsvFormat; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CsvFormat") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut has_header__ = None; + let mut delimiter__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HasHeader => { + if has_header__.is_some() { + return Err(serde::de::Error::duplicate_field("hasHeader")); + } + has_header__ = Some(map.next_value()?); + } + GeneratedField::Delimiter => { + if delimiter__.is_some() { + return Err(serde::de::Error::duplicate_field("delimiter")); + } + delimiter__ = Some(map.next_value()?); + } + } + } + Ok(CsvFormat { + has_header: has_header__.unwrap_or_default(), + delimiter: delimiter__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.CsvFormat", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CubeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CubeNode", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CubeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CubeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.CubeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(CubeNode { + expr: expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.CubeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DateUnit { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Day => "Day", + Self::DateMillisecond => "DateMillisecond", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for DateUnit { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "Day", + "DateMillisecond", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DateUnit; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(DateUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(DateUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "Day" => Ok(DateUnit::Day), + "DateMillisecond" => Ok(DateUnit::DateMillisecond), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for Decimal { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.whole != 0 { + len += 1; + } + if self.fractional != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?; + if self.whole != 0 { + struct_ser.serialize_field("whole", ToString::to_string(&self.whole).as_str())?; + } + if self.fractional != 0 { + struct_ser.serialize_field("fractional", ToString::to_string(&self.fractional).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Decimal { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "whole", + "fractional", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Whole, + Fractional, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "whole" => Ok(GeneratedField::Whole), + "fractional" => Ok(GeneratedField::Fractional), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Decimal; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Decimal") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut whole__ = None; + let mut fractional__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Whole => { + if whole__.is_some() { + return Err(serde::de::Error::duplicate_field("whole")); + } + whole__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + GeneratedField::Fractional => { + if fractional__.is_some() { + return Err(serde::de::Error::duplicate_field("fractional")); + } + fractional__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(Decimal { + whole: whole__.unwrap_or_default(), + fractional: fractional__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Decimal", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Decimal128 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.value.is_empty() { + len += 1; + } + if self.p != 0 { + len += 1; + } + if self.s != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Decimal128", len)?; + if !self.value.is_empty() { + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if self.p != 0 { + struct_ser.serialize_field("p", ToString::to_string(&self.p).as_str())?; + } + if self.s != 0 { + struct_ser.serialize_field("s", ToString::to_string(&self.s).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Decimal128 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "value", + "p", + "s", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Value, + P, + S, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "value" => Ok(GeneratedField::Value), + "p" => Ok(GeneratedField::P), + "s" => Ok(GeneratedField::S), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Decimal128; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Decimal128") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + let mut p__ = None; + let mut s__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some( + map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0 + ); + } + GeneratedField::P => { + if p__.is_some() { + return Err(serde::de::Error::duplicate_field("p")); + } + p__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + GeneratedField::S => { + if s__.is_some() { + return Err(serde::de::Error::duplicate_field("s")); + } + s__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(Decimal128 { + value: value__.unwrap_or_default(), + p: p__.unwrap_or_default(), + s: s__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Decimal128", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DfField { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.field.is_some() { + len += 1; + } + if self.qualifier.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.DfField", len)?; + if let Some(v) = self.field.as_ref() { + struct_ser.serialize_field("field", v)?; + } + if let Some(v) = self.qualifier.as_ref() { + struct_ser.serialize_field("qualifier", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DfField { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "field", + "qualifier", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Field, + Qualifier, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "field" => Ok(GeneratedField::Field), + "qualifier" => Ok(GeneratedField::Qualifier), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DfField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.DfField") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field__ = None; + let mut qualifier__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Field => { + if field__.is_some() { + return Err(serde::de::Error::duplicate_field("field")); + } + field__ = Some(map.next_value()?); + } + GeneratedField::Qualifier => { + if qualifier__.is_some() { + return Err(serde::de::Error::duplicate_field("qualifier")); + } + qualifier__ = Some(map.next_value()?); + } + } + } + Ok(DfField { + field: field__, + qualifier: qualifier__, + }) + } + } + deserializer.deserialize_struct("datafusion.DfField", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DfSchema { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.columns.is_empty() { + len += 1; + } + if !self.metadata.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.DfSchema", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; + } + if !self.metadata.is_empty() { + struct_ser.serialize_field("metadata", &self.metadata)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DfSchema { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "columns", + "metadata", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Columns, + Metadata, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "columns" => Ok(GeneratedField::Columns), + "metadata" => Ok(GeneratedField::Metadata), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DfSchema; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.DfSchema") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut columns__ = None; + let mut metadata__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); + } + columns__ = Some(map.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = Some( + map.next_value::>()? + ); + } + } + } + Ok(DfSchema { + columns: columns__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.DfSchema", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Dictionary { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.key.is_some() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Dictionary", len)?; + if let Some(v) = self.key.as_ref() { + struct_ser.serialize_field("key", v)?; + } + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Dictionary { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Dictionary; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Dictionary") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some(map.next_value()?); + } + } + } + Ok(Dictionary { + key: key__, + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.Dictionary", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DistinctNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.DistinctNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DistinctNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DistinctNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.DistinctNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + } + } + Ok(DistinctNode { + input: input__, + }) + } + } + deserializer.deserialize_struct("datafusion.DistinctNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EmptyMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("datafusion.EmptyMessage", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EmptyMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EmptyMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.EmptyMessage") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(EmptyMessage { + }) + } + } + deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EmptyRelationNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.produce_one_row { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.EmptyRelationNode", len)?; + if self.produce_one_row { + struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EmptyRelationNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "produceOneRow", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ProduceOneRow, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "produceOneRow" => Ok(GeneratedField::ProduceOneRow), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EmptyRelationNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.EmptyRelationNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut produce_one_row__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ProduceOneRow => { + if produce_one_row__.is_some() { + return Err(serde::de::Error::duplicate_field("produceOneRow")); + } + produce_one_row__ = Some(map.next_value()?); + } + } + } + Ok(EmptyRelationNode { + produce_one_row: produce_one_row__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.EmptyRelationNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ExplainNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.verbose { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ExplainNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.verbose { + struct_ser.serialize_field("verbose", &self.verbose)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ExplainNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "verbose", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Verbose, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "verbose" => Ok(GeneratedField::Verbose), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ExplainNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ExplainNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut verbose__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Verbose => { + if verbose__.is_some() { + return Err(serde::de::Error::duplicate_field("verbose")); + } + verbose__ = Some(map.next_value()?); + } + } + } + Ok(ExplainNode { + input: input__, + verbose: verbose__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ExplainNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Field { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.arrow_type.is_some() { + len += 1; + } + if self.nullable { + len += 1; + } + if !self.children.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Field", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + if self.nullable { + struct_ser.serialize_field("nullable", &self.nullable)?; + } + if !self.children.is_empty() { + struct_ser.serialize_field("children", &self.children)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Field { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "arrowType", + "nullable", + "children", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + ArrowType, + Nullable, + Children, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "arrowType" => Ok(GeneratedField::ArrowType), + "nullable" => Ok(GeneratedField::Nullable), + "children" => Ok(GeneratedField::Children), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Field; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Field") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut arrow_type__ = None; + let mut nullable__ = None; + let mut children__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::ArrowType => { + if arrow_type__.is_some() { + return Err(serde::de::Error::duplicate_field("arrowType")); + } + arrow_type__ = Some(map.next_value()?); + } + GeneratedField::Nullable => { + if nullable__.is_some() { + return Err(serde::de::Error::duplicate_field("nullable")); + } + nullable__ = Some(map.next_value()?); + } + GeneratedField::Children => { + if children__.is_some() { + return Err(serde::de::Error::duplicate_field("children")); + } + children__ = Some(map.next_value()?); + } + } + } + Ok(Field { + name: name__.unwrap_or_default(), + arrow_type: arrow_type__, + nullable: nullable__.unwrap_or_default(), + children: children__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Field", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for FixedSizeBinary { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.length != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeBinary", len)?; + if self.length != 0 { + struct_ser.serialize_field("length", &self.length)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FixedSizeBinary { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "length", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Length, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "length" => Ok(GeneratedField::Length), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FixedSizeBinary; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.FixedSizeBinary") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut length__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Length => { + if length__.is_some() { + return Err(serde::de::Error::duplicate_field("length")); + } + length__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(FixedSizeBinary { + length: length__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.FixedSizeBinary", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for FixedSizeList { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.field_type.is_some() { + len += 1; + } + if self.list_size != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeList", len)?; + if let Some(v) = self.field_type.as_ref() { + struct_ser.serialize_field("fieldType", v)?; + } + if self.list_size != 0 { + struct_ser.serialize_field("listSize", &self.list_size)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FixedSizeList { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fieldType", + "listSize", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FieldType, + ListSize, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fieldType" => Ok(GeneratedField::FieldType), + "listSize" => Ok(GeneratedField::ListSize), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FixedSizeList; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.FixedSizeList") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field_type__ = None; + let mut list_size__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FieldType => { + if field_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fieldType")); + } + field_type__ = Some(map.next_value()?); + } + GeneratedField::ListSize => { + if list_size__.is_some() { + return Err(serde::de::Error::duplicate_field("listSize")); + } + list_size__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(FixedSizeList { + field_type: field_type__, + list_size: list_size__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.FixedSizeList", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GetIndexedField { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.key.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.GetIndexedField", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.key.as_ref() { + struct_ser.serialize_field("key", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GetIndexedField { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "key", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Key, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "key" => Ok(GeneratedField::Key), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GetIndexedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.GetIndexedField") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut key__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map.next_value()?); + } + } + } + Ok(GetIndexedField { + expr: expr__, + key: key__, + }) + } + } + deserializer.deserialize_struct("datafusion.GetIndexedField", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GroupingSetNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.GroupingSetNode", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GroupingSetNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GroupingSetNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.GroupingSetNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(GroupingSetNode { + expr: expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.GroupingSetNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for HashRepartition { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.hash_expr.is_empty() { + len += 1; + } + if self.partition_count != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.HashRepartition", len)?; + if !self.hash_expr.is_empty() { + struct_ser.serialize_field("hashExpr", &self.hash_expr)?; + } + if self.partition_count != 0 { + struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for HashRepartition { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hashExpr", + "partitionCount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HashExpr, + PartitionCount, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "hashExpr" => Ok(GeneratedField::HashExpr), + "partitionCount" => Ok(GeneratedField::PartitionCount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = HashRepartition; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.HashRepartition") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hash_expr__ = None; + let mut partition_count__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HashExpr => { + if hash_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("hashExpr")); + } + hash_expr__ = Some(map.next_value()?); + } + GeneratedField::PartitionCount => { + if partition_count__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionCount")); + } + partition_count__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(HashRepartition { + hash_expr: hash_expr__.unwrap_or_default(), + partition_count: partition_count__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.HashRepartition", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ILikeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.negated { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + if self.pattern.is_some() { + len += 1; + } + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ILikeNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ILikeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "negated", + "expr", + "pattern", + "escapeChar", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Negated, + Expr, + Pattern, + EscapeChar, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "negated" => Ok(GeneratedField::Negated), + "expr" => Ok(GeneratedField::Expr), + "pattern" => Ok(GeneratedField::Pattern), + "escapeChar" => Ok(GeneratedField::EscapeChar), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ILikeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ILikeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut negated__ = None; + let mut expr__ = None; + let mut pattern__ = None; + let mut escape_char__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Pattern => { + if pattern__.is_some() { + return Err(serde::de::Error::duplicate_field("pattern")); + } + pattern__ = Some(map.next_value()?); + } + GeneratedField::EscapeChar => { + if escape_char__.is_some() { + return Err(serde::de::Error::duplicate_field("escapeChar")); + } + escape_char__ = Some(map.next_value()?); + } + } + } + Ok(ILikeNode { + negated: negated__.unwrap_or_default(), + expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ILikeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InListNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.list.is_empty() { + len += 1; + } + if self.negated { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.InListNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.list.is_empty() { + struct_ser.serialize_field("list", &self.list)?; + } + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InListNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "list", + "negated", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + List, + Negated, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "list" => Ok(GeneratedField::List), + "negated" => Ok(GeneratedField::Negated), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InListNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.InListNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut list__ = None; + let mut negated__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::List => { + if list__.is_some() { + return Err(serde::de::Error::duplicate_field("list")); + } + list__ = Some(map.next_value()?); + } + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + } + } + Ok(InListNode { + expr: expr__, + list: list__.unwrap_or_default(), + negated: negated__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.InListNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IntervalUnit { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::YearMonth => "YearMonth", + Self::DayTime => "DayTime", + Self::MonthDayNano => "MonthDayNano", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for IntervalUnit { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "YearMonth", + "DayTime", + "MonthDayNano", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IntervalUnit; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(IntervalUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(IntervalUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "YearMonth" => Ok(IntervalUnit::YearMonth), + "DayTime" => Ok(IntervalUnit::DayTime), + "MonthDayNano" => Ok(IntervalUnit::MonthDayNano), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for IsFalse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsFalse", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsFalse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsFalse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsFalse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsFalse { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsFalse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsNotFalse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotFalse", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsNotFalse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsNotFalse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsNotFalse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsNotFalse { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsNotFalse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsNotNull { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotNull", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsNotNull { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsNotNull; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsNotNull") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsNotNull { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsNotNull", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsNotTrue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotTrue", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsNotTrue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsNotTrue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsNotTrue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsNotTrue { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsNotTrue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsNotUnknown { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotUnknown", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsNotUnknown { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsNotUnknown; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsNotUnknown") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsNotUnknown { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsNotUnknown", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsNull { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNull", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsNull { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsNull; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsNull") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsNull { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsNull", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsTrue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsTrue", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsTrue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsTrue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsTrue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsTrue { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsTrue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IsUnknown { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IsUnknown", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IsUnknown { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IsUnknown; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.IsUnknown") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(IsUnknown { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.IsUnknown", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for JoinConstraint { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::On => "ON", + Self::Using => "USING", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for JoinConstraint { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ON", + "USING", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinConstraint; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinConstraint::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinConstraint::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ON" => Ok(JoinConstraint::On), + "USING" => Ok(JoinConstraint::Using), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for JoinNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.left.is_some() { + len += 1; + } + if self.right.is_some() { + len += 1; + } + if self.join_type != 0 { + len += 1; + } + if self.join_constraint != 0 { + len += 1; + } + if !self.left_join_column.is_empty() { + len += 1; + } + if !self.right_join_column.is_empty() { + len += 1; + } + if self.null_equals_null { + len += 1; + } + if self.filter.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.JoinNode", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; + } + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; + } + if self.join_type != 0 { + let v = JoinType::from_i32(self.join_type) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; + struct_ser.serialize_field("joinType", &v)?; + } + if self.join_constraint != 0 { + let v = JoinConstraint::from_i32(self.join_constraint) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_constraint)))?; + struct_ser.serialize_field("joinConstraint", &v)?; + } + if !self.left_join_column.is_empty() { + struct_ser.serialize_field("leftJoinColumn", &self.left_join_column)?; + } + if !self.right_join_column.is_empty() { + struct_ser.serialize_field("rightJoinColumn", &self.right_join_column)?; + } + if self.null_equals_null { + struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?; + } + if let Some(v) = self.filter.as_ref() { + struct_ser.serialize_field("filter", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for JoinNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "left", + "right", + "joinType", + "joinConstraint", + "leftJoinColumn", + "rightJoinColumn", + "nullEqualsNull", + "filter", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Left, + Right, + JoinType, + JoinConstraint, + LeftJoinColumn, + RightJoinColumn, + NullEqualsNull, + Filter, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), + "joinType" => Ok(GeneratedField::JoinType), + "joinConstraint" => Ok(GeneratedField::JoinConstraint), + "leftJoinColumn" => Ok(GeneratedField::LeftJoinColumn), + "rightJoinColumn" => Ok(GeneratedField::RightJoinColumn), + "nullEqualsNull" => Ok(GeneratedField::NullEqualsNull), + "filter" => Ok(GeneratedField::Filter), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.JoinNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut left__ = None; + let mut right__ = None; + let mut join_type__ = None; + let mut join_constraint__ = None; + let mut left_join_column__ = None; + let mut right_join_column__ = None; + let mut null_equals_null__ = None; + let mut filter__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); + } + left__ = Some(map.next_value()?); + } + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); + } + right__ = Some(map.next_value()?); + } + GeneratedField::JoinType => { + if join_type__.is_some() { + return Err(serde::de::Error::duplicate_field("joinType")); + } + join_type__ = Some(map.next_value::()? as i32); + } + GeneratedField::JoinConstraint => { + if join_constraint__.is_some() { + return Err(serde::de::Error::duplicate_field("joinConstraint")); + } + join_constraint__ = Some(map.next_value::()? as i32); + } + GeneratedField::LeftJoinColumn => { + if left_join_column__.is_some() { + return Err(serde::de::Error::duplicate_field("leftJoinColumn")); + } + left_join_column__ = Some(map.next_value()?); + } + GeneratedField::RightJoinColumn => { + if right_join_column__.is_some() { + return Err(serde::de::Error::duplicate_field("rightJoinColumn")); + } + right_join_column__ = Some(map.next_value()?); + } + GeneratedField::NullEqualsNull => { + if null_equals_null__.is_some() { + return Err(serde::de::Error::duplicate_field("nullEqualsNull")); + } + null_equals_null__ = Some(map.next_value()?); + } + GeneratedField::Filter => { + if filter__.is_some() { + return Err(serde::de::Error::duplicate_field("filter")); + } + filter__ = Some(map.next_value()?); + } + } + } + Ok(JoinNode { + left: left__, + right: right__, + join_type: join_type__.unwrap_or_default(), + join_constraint: join_constraint__.unwrap_or_default(), + left_join_column: left_join_column__.unwrap_or_default(), + right_join_column: right_join_column__.unwrap_or_default(), + null_equals_null: null_equals_null__.unwrap_or_default(), + filter: filter__, + }) + } + } + deserializer.deserialize_struct("datafusion.JoinNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for JoinType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Inner => "INNER", + Self::Left => "LEFT", + Self::Right => "RIGHT", + Self::Full => "FULL", + Self::Semi => "SEMI", + Self::Anti => "ANTI", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for JoinType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "INNER", + "LEFT", + "RIGHT", + "FULL", + "SEMI", + "ANTI", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "INNER" => Ok(JoinType::Inner), + "LEFT" => Ok(JoinType::Left), + "RIGHT" => Ok(JoinType::Right), + "FULL" => Ok(JoinType::Full), + "SEMI" => Ok(JoinType::Semi), + "ANTI" => Ok(JoinType::Anti), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for LikeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.negated { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + if self.pattern.is_some() { + len += 1; + } + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LikeNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LikeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "negated", + "expr", + "pattern", + "escapeChar", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Negated, + Expr, + Pattern, + EscapeChar, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "negated" => Ok(GeneratedField::Negated), + "expr" => Ok(GeneratedField::Expr), + "pattern" => Ok(GeneratedField::Pattern), + "escapeChar" => Ok(GeneratedField::EscapeChar), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LikeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LikeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut negated__ = None; + let mut expr__ = None; + let mut pattern__ = None; + let mut escape_char__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Pattern => { + if pattern__.is_some() { + return Err(serde::de::Error::duplicate_field("pattern")); + } + pattern__ = Some(map.next_value()?); + } + GeneratedField::EscapeChar => { + if escape_char__.is_some() { + return Err(serde::de::Error::duplicate_field("escapeChar")); + } + escape_char__ = Some(map.next_value()?); + } + } + } + Ok(LikeNode { + negated: negated__.unwrap_or_default(), + expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LikeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LimitNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.skip != 0 { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LimitNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.skip != 0 { + struct_ser.serialize_field("skip", ToString::to_string(&self.skip).as_str())?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LimitNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "skip", + "fetch", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Skip, + Fetch, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "skip" => Ok(GeneratedField::Skip), + "fetch" => Ok(GeneratedField::Fetch), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LimitNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LimitNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut skip__ = None; + let mut fetch__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Skip => { + if skip__.is_some() { + return Err(serde::de::Error::duplicate_field("skip")); + } + skip__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(LimitNode { + input: input__, + skip: skip__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LimitNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for List { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.field_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.List", len)?; + if let Some(v) = self.field_type.as_ref() { + struct_ser.serialize_field("fieldType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for List { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fieldType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FieldType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fieldType" => Ok(GeneratedField::FieldType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = List; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.List") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FieldType => { + if field_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fieldType")); + } + field_type__ = Some(map.next_value()?); + } + } + } + Ok(List { + field_type: field_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.List", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ListingTableScanNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.table_name.is_empty() { + len += 1; + } + if !self.paths.is_empty() { + len += 1; + } + if !self.file_extension.is_empty() { + len += 1; + } + if self.projection.is_some() { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + if !self.filters.is_empty() { + len += 1; + } + if !self.table_partition_cols.is_empty() { + len += 1; + } + if self.collect_stat { + len += 1; + } + if self.target_partitions != 0 { + len += 1; + } + if self.file_format_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?; + if !self.table_name.is_empty() { + struct_ser.serialize_field("tableName", &self.table_name)?; + } + if !self.paths.is_empty() { + struct_ser.serialize_field("paths", &self.paths)?; + } + if !self.file_extension.is_empty() { + struct_ser.serialize_field("fileExtension", &self.file_extension)?; + } + if let Some(v) = self.projection.as_ref() { + struct_ser.serialize_field("projection", v)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if !self.filters.is_empty() { + struct_ser.serialize_field("filters", &self.filters)?; + } + if !self.table_partition_cols.is_empty() { + struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; + } + if self.collect_stat { + struct_ser.serialize_field("collectStat", &self.collect_stat)?; + } + if self.target_partitions != 0 { + struct_ser.serialize_field("targetPartitions", &self.target_partitions)?; + } + if let Some(v) = self.file_format_type.as_ref() { + match v { + listing_table_scan_node::FileFormatType::Csv(v) => { + struct_ser.serialize_field("csv", v)?; + } + listing_table_scan_node::FileFormatType::Parquet(v) => { + struct_ser.serialize_field("parquet", v)?; + } + listing_table_scan_node::FileFormatType::Avro(v) => { + struct_ser.serialize_field("avro", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ListingTableScanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "tableName", + "paths", + "fileExtension", + "projection", + "schema", + "filters", + "tablePartitionCols", + "collectStat", + "targetPartitions", + "csv", + "parquet", + "avro", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TableName, + Paths, + FileExtension, + Projection, + Schema, + Filters, + TablePartitionCols, + CollectStat, + TargetPartitions, + Csv, + Parquet, + Avro, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "tableName" => Ok(GeneratedField::TableName), + "paths" => Ok(GeneratedField::Paths), + "fileExtension" => Ok(GeneratedField::FileExtension), + "projection" => Ok(GeneratedField::Projection), + "schema" => Ok(GeneratedField::Schema), + "filters" => Ok(GeneratedField::Filters), + "tablePartitionCols" => Ok(GeneratedField::TablePartitionCols), + "collectStat" => Ok(GeneratedField::CollectStat), + "targetPartitions" => Ok(GeneratedField::TargetPartitions), + "csv" => Ok(GeneratedField::Csv), + "parquet" => Ok(GeneratedField::Parquet), + "avro" => Ok(GeneratedField::Avro), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ListingTableScanNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ListingTableScanNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut table_name__ = None; + let mut paths__ = None; + let mut file_extension__ = None; + let mut projection__ = None; + let mut schema__ = None; + let mut filters__ = None; + let mut table_partition_cols__ = None; + let mut collect_stat__ = None; + let mut target_partitions__ = None; + let mut file_format_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::TableName => { + if table_name__.is_some() { + return Err(serde::de::Error::duplicate_field("tableName")); + } + table_name__ = Some(map.next_value()?); + } + GeneratedField::Paths => { + if paths__.is_some() { + return Err(serde::de::Error::duplicate_field("paths")); + } + paths__ = Some(map.next_value()?); + } + GeneratedField::FileExtension => { + if file_extension__.is_some() { + return Err(serde::de::Error::duplicate_field("fileExtension")); + } + file_extension__ = Some(map.next_value()?); + } + GeneratedField::Projection => { + if projection__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); + } + projection__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = Some(map.next_value()?); + } + GeneratedField::Filters => { + if filters__.is_some() { + return Err(serde::de::Error::duplicate_field("filters")); + } + filters__ = Some(map.next_value()?); + } + GeneratedField::TablePartitionCols => { + if table_partition_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("tablePartitionCols")); + } + table_partition_cols__ = Some(map.next_value()?); + } + GeneratedField::CollectStat => { + if collect_stat__.is_some() { + return Err(serde::de::Error::duplicate_field("collectStat")); + } + collect_stat__ = Some(map.next_value()?); + } + GeneratedField::TargetPartitions => { + if target_partitions__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPartitions")); + } + target_partitions__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + GeneratedField::Csv => { + if file_format_type__.is_some() { + return Err(serde::de::Error::duplicate_field("csv")); + } + file_format_type__ = Some(listing_table_scan_node::FileFormatType::Csv(map.next_value()?)); + } + GeneratedField::Parquet => { + if file_format_type__.is_some() { + return Err(serde::de::Error::duplicate_field("parquet")); + } + file_format_type__ = Some(listing_table_scan_node::FileFormatType::Parquet(map.next_value()?)); + } + GeneratedField::Avro => { + if file_format_type__.is_some() { + return Err(serde::de::Error::duplicate_field("avro")); + } + file_format_type__ = Some(listing_table_scan_node::FileFormatType::Avro(map.next_value()?)); + } + } + } + Ok(ListingTableScanNode { + table_name: table_name__.unwrap_or_default(), + paths: paths__.unwrap_or_default(), + file_extension: file_extension__.unwrap_or_default(), + projection: projection__, + schema: schema__, + filters: filters__.unwrap_or_default(), + table_partition_cols: table_partition_cols__.unwrap_or_default(), + collect_stat: collect_stat__.unwrap_or_default(), + target_partitions: target_partitions__.unwrap_or_default(), + file_format_type: file_format_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.ListingTableScanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalExprList { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprList", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalExprList { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalExprList; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalExprList") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(LogicalExprList { + expr: expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalExprList", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNode", len)?; + if let Some(v) = self.expr_type.as_ref() { + match v { + logical_expr_node::ExprType::Column(v) => { + struct_ser.serialize_field("column", v)?; + } + logical_expr_node::ExprType::Alias(v) => { + struct_ser.serialize_field("alias", v)?; + } + logical_expr_node::ExprType::Literal(v) => { + struct_ser.serialize_field("literal", v)?; + } + logical_expr_node::ExprType::BinaryExpr(v) => { + struct_ser.serialize_field("binaryExpr", v)?; + } + logical_expr_node::ExprType::AggregateExpr(v) => { + struct_ser.serialize_field("aggregateExpr", v)?; + } + logical_expr_node::ExprType::IsNullExpr(v) => { + struct_ser.serialize_field("isNullExpr", v)?; + } + logical_expr_node::ExprType::IsNotNullExpr(v) => { + struct_ser.serialize_field("isNotNullExpr", v)?; + } + logical_expr_node::ExprType::NotExpr(v) => { + struct_ser.serialize_field("notExpr", v)?; + } + logical_expr_node::ExprType::Between(v) => { + struct_ser.serialize_field("between", v)?; + } + logical_expr_node::ExprType::Case(v) => { + struct_ser.serialize_field("case", v)?; + } + logical_expr_node::ExprType::Cast(v) => { + struct_ser.serialize_field("cast", v)?; + } + logical_expr_node::ExprType::Sort(v) => { + struct_ser.serialize_field("sort", v)?; + } + logical_expr_node::ExprType::Negative(v) => { + struct_ser.serialize_field("negative", v)?; + } + logical_expr_node::ExprType::InList(v) => { + struct_ser.serialize_field("inList", v)?; + } + logical_expr_node::ExprType::Wildcard(v) => { + struct_ser.serialize_field("wildcard", v)?; + } + logical_expr_node::ExprType::ScalarFunction(v) => { + struct_ser.serialize_field("scalarFunction", v)?; + } + logical_expr_node::ExprType::TryCast(v) => { + struct_ser.serialize_field("tryCast", v)?; + } + logical_expr_node::ExprType::WindowExpr(v) => { + struct_ser.serialize_field("windowExpr", v)?; + } + logical_expr_node::ExprType::AggregateUdfExpr(v) => { + struct_ser.serialize_field("aggregateUdfExpr", v)?; + } + logical_expr_node::ExprType::ScalarUdfExpr(v) => { + struct_ser.serialize_field("scalarUdfExpr", v)?; + } + logical_expr_node::ExprType::GetIndexedField(v) => { + struct_ser.serialize_field("getIndexedField", v)?; + } + logical_expr_node::ExprType::GroupingSet(v) => { + struct_ser.serialize_field("groupingSet", v)?; + } + logical_expr_node::ExprType::Cube(v) => { + struct_ser.serialize_field("cube", v)?; + } + logical_expr_node::ExprType::Rollup(v) => { + struct_ser.serialize_field("rollup", v)?; + } + logical_expr_node::ExprType::IsTrue(v) => { + struct_ser.serialize_field("isTrue", v)?; + } + logical_expr_node::ExprType::IsFalse(v) => { + struct_ser.serialize_field("isFalse", v)?; + } + logical_expr_node::ExprType::IsUnknown(v) => { + struct_ser.serialize_field("isUnknown", v)?; + } + logical_expr_node::ExprType::IsNotTrue(v) => { + struct_ser.serialize_field("isNotTrue", v)?; + } + logical_expr_node::ExprType::IsNotFalse(v) => { + struct_ser.serialize_field("isNotFalse", v)?; + } + logical_expr_node::ExprType::IsNotUnknown(v) => { + struct_ser.serialize_field("isNotUnknown", v)?; + } + logical_expr_node::ExprType::Like(v) => { + struct_ser.serialize_field("like", v)?; + } + logical_expr_node::ExprType::Ilike(v) => { + struct_ser.serialize_field("ilike", v)?; + } + logical_expr_node::ExprType::SimilarTo(v) => { + struct_ser.serialize_field("similarTo", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "column", + "alias", + "literal", + "binaryExpr", + "aggregateExpr", + "isNullExpr", + "isNotNullExpr", + "notExpr", + "between", + "case", + "cast", + "sort", + "negative", + "inList", + "wildcard", + "scalarFunction", + "tryCast", + "windowExpr", + "aggregateUdfExpr", + "scalarUdfExpr", + "getIndexedField", + "groupingSet", + "cube", + "rollup", + "isTrue", + "isFalse", + "isUnknown", + "isNotTrue", + "isNotFalse", + "isNotUnknown", + "like", + "ilike", + "similarTo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Column, + Alias, + Literal, + BinaryExpr, + AggregateExpr, + IsNullExpr, + IsNotNullExpr, + NotExpr, + Between, + Case, + Cast, + Sort, + Negative, + InList, + Wildcard, + ScalarFunction, + TryCast, + WindowExpr, + AggregateUdfExpr, + ScalarUdfExpr, + GetIndexedField, + GroupingSet, + Cube, + Rollup, + IsTrue, + IsFalse, + IsUnknown, + IsNotTrue, + IsNotFalse, + IsNotUnknown, + Like, + Ilike, + SimilarTo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "column" => Ok(GeneratedField::Column), + "alias" => Ok(GeneratedField::Alias), + "literal" => Ok(GeneratedField::Literal), + "binaryExpr" => Ok(GeneratedField::BinaryExpr), + "aggregateExpr" => Ok(GeneratedField::AggregateExpr), + "isNullExpr" => Ok(GeneratedField::IsNullExpr), + "isNotNullExpr" => Ok(GeneratedField::IsNotNullExpr), + "notExpr" => Ok(GeneratedField::NotExpr), + "between" => Ok(GeneratedField::Between), + "case" => Ok(GeneratedField::Case), + "cast" => Ok(GeneratedField::Cast), + "sort" => Ok(GeneratedField::Sort), + "negative" => Ok(GeneratedField::Negative), + "inList" => Ok(GeneratedField::InList), + "wildcard" => Ok(GeneratedField::Wildcard), + "scalarFunction" => Ok(GeneratedField::ScalarFunction), + "tryCast" => Ok(GeneratedField::TryCast), + "windowExpr" => Ok(GeneratedField::WindowExpr), + "aggregateUdfExpr" => Ok(GeneratedField::AggregateUdfExpr), + "scalarUdfExpr" => Ok(GeneratedField::ScalarUdfExpr), + "getIndexedField" => Ok(GeneratedField::GetIndexedField), + "groupingSet" => Ok(GeneratedField::GroupingSet), + "cube" => Ok(GeneratedField::Cube), + "rollup" => Ok(GeneratedField::Rollup), + "isTrue" => Ok(GeneratedField::IsTrue), + "isFalse" => Ok(GeneratedField::IsFalse), + "isUnknown" => Ok(GeneratedField::IsUnknown), + "isNotTrue" => Ok(GeneratedField::IsNotTrue), + "isNotFalse" => Ok(GeneratedField::IsNotFalse), + "isNotUnknown" => Ok(GeneratedField::IsNotUnknown), + "like" => Ok(GeneratedField::Like), + "ilike" => Ok(GeneratedField::Ilike), + "similarTo" => Ok(GeneratedField::SimilarTo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Column => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("column")); + } + expr_type__ = Some(logical_expr_node::ExprType::Column(map.next_value()?)); + } + GeneratedField::Alias => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + expr_type__ = Some(logical_expr_node::ExprType::Alias(map.next_value()?)); + } + GeneratedField::Literal => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("literal")); + } + expr_type__ = Some(logical_expr_node::ExprType::Literal(map.next_value()?)); + } + GeneratedField::BinaryExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("binaryExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::BinaryExpr(map.next_value()?)); + } + GeneratedField::AggregateExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregateExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::AggregateExpr(map.next_value()?)); + } + GeneratedField::IsNullExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNullExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsNullExpr(map.next_value()?)); + } + GeneratedField::IsNotNullExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotNullExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsNotNullExpr(map.next_value()?)); + } + GeneratedField::NotExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("notExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::NotExpr(map.next_value()?)); + } + GeneratedField::Between => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("between")); + } + expr_type__ = Some(logical_expr_node::ExprType::Between(map.next_value()?)); + } + GeneratedField::Case => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("case")); + } + expr_type__ = Some(logical_expr_node::ExprType::Case(map.next_value()?)); + } + GeneratedField::Cast => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("cast")); + } + expr_type__ = Some(logical_expr_node::ExprType::Cast(map.next_value()?)); + } + GeneratedField::Sort => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sort")); + } + expr_type__ = Some(logical_expr_node::ExprType::Sort(map.next_value()?)); + } + GeneratedField::Negative => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("negative")); + } + expr_type__ = Some(logical_expr_node::ExprType::Negative(map.next_value()?)); + } + GeneratedField::InList => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("inList")); + } + expr_type__ = Some(logical_expr_node::ExprType::InList(map.next_value()?)); + } + GeneratedField::Wildcard => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("wildcard")); + } + expr_type__ = Some(logical_expr_node::ExprType::Wildcard(map.next_value()?)); + } + GeneratedField::ScalarFunction => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("scalarFunction")); + } + expr_type__ = Some(logical_expr_node::ExprType::ScalarFunction(map.next_value()?)); + } + GeneratedField::TryCast => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("tryCast")); + } + expr_type__ = Some(logical_expr_node::ExprType::TryCast(map.next_value()?)); + } + GeneratedField::WindowExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::WindowExpr(map.next_value()?)); + } + GeneratedField::AggregateUdfExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregateUdfExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::AggregateUdfExpr(map.next_value()?)); + } + GeneratedField::ScalarUdfExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("scalarUdfExpr")); + } + expr_type__ = Some(logical_expr_node::ExprType::ScalarUdfExpr(map.next_value()?)); + } + GeneratedField::GetIndexedField => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("getIndexedField")); + } + expr_type__ = Some(logical_expr_node::ExprType::GetIndexedField(map.next_value()?)); + } + GeneratedField::GroupingSet => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("groupingSet")); + } + expr_type__ = Some(logical_expr_node::ExprType::GroupingSet(map.next_value()?)); + } + GeneratedField::Cube => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("cube")); + } + expr_type__ = Some(logical_expr_node::ExprType::Cube(map.next_value()?)); + } + GeneratedField::Rollup => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("rollup")); + } + expr_type__ = Some(logical_expr_node::ExprType::Rollup(map.next_value()?)); + } + GeneratedField::IsTrue => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isTrue")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsTrue(map.next_value()?)); + } + GeneratedField::IsFalse => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isFalse")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsFalse(map.next_value()?)); + } + GeneratedField::IsUnknown => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isUnknown")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsUnknown(map.next_value()?)); + } + GeneratedField::IsNotTrue => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotTrue")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsNotTrue(map.next_value()?)); + } + GeneratedField::IsNotFalse => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotFalse")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsNotFalse(map.next_value()?)); + } + GeneratedField::IsNotUnknown => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotUnknown")); + } + expr_type__ = Some(logical_expr_node::ExprType::IsNotUnknown(map.next_value()?)); + } + GeneratedField::Like => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("like")); + } + expr_type__ = Some(logical_expr_node::ExprType::Like(map.next_value()?)); + } + GeneratedField::Ilike => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("ilike")); + } + expr_type__ = Some(logical_expr_node::ExprType::Ilike(map.next_value()?)); + } + GeneratedField::SimilarTo => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("similarTo")); + } + expr_type__ = Some(logical_expr_node::ExprType::SimilarTo(map.next_value()?)); + } + } + } + Ok(LogicalExprNode { + expr_type: expr_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalExtensionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.node.is_empty() { + len += 1; + } + if !self.inputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExtensionNode", len)?; + if !self.node.is_empty() { + struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?; + } + if !self.inputs.is_empty() { + struct_ser.serialize_field("inputs", &self.inputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalExtensionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "node", + "inputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Node, + Inputs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "node" => Ok(GeneratedField::Node), + "inputs" => Ok(GeneratedField::Inputs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalExtensionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalExtensionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut node__ = None; + let mut inputs__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Node => { + if node__.is_some() { + return Err(serde::de::Error::duplicate_field("node")); + } + node__ = Some( + map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0 + ); + } + GeneratedField::Inputs => { + if inputs__.is_some() { + return Err(serde::de::Error::duplicate_field("inputs")); + } + inputs__ = Some(map.next_value()?); + } + } + } + Ok(LogicalExtensionNode { + node: node__.unwrap_or_default(), + inputs: inputs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalExtensionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalPlanNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.logical_plan_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalPlanNode", len)?; + if let Some(v) = self.logical_plan_type.as_ref() { + match v { + logical_plan_node::LogicalPlanType::ListingScan(v) => { + struct_ser.serialize_field("listingScan", v)?; + } + logical_plan_node::LogicalPlanType::Projection(v) => { + struct_ser.serialize_field("projection", v)?; + } + logical_plan_node::LogicalPlanType::Selection(v) => { + struct_ser.serialize_field("selection", v)?; + } + logical_plan_node::LogicalPlanType::Limit(v) => { + struct_ser.serialize_field("limit", v)?; + } + logical_plan_node::LogicalPlanType::Aggregate(v) => { + struct_ser.serialize_field("aggregate", v)?; + } + logical_plan_node::LogicalPlanType::Join(v) => { + struct_ser.serialize_field("join", v)?; + } + logical_plan_node::LogicalPlanType::Sort(v) => { + struct_ser.serialize_field("sort", v)?; + } + logical_plan_node::LogicalPlanType::Repartition(v) => { + struct_ser.serialize_field("repartition", v)?; + } + logical_plan_node::LogicalPlanType::EmptyRelation(v) => { + struct_ser.serialize_field("emptyRelation", v)?; + } + logical_plan_node::LogicalPlanType::CreateExternalTable(v) => { + struct_ser.serialize_field("createExternalTable", v)?; + } + logical_plan_node::LogicalPlanType::Explain(v) => { + struct_ser.serialize_field("explain", v)?; + } + logical_plan_node::LogicalPlanType::Window(v) => { + struct_ser.serialize_field("window", v)?; + } + logical_plan_node::LogicalPlanType::Analyze(v) => { + struct_ser.serialize_field("analyze", v)?; + } + logical_plan_node::LogicalPlanType::CrossJoin(v) => { + struct_ser.serialize_field("crossJoin", v)?; + } + logical_plan_node::LogicalPlanType::Values(v) => { + struct_ser.serialize_field("values", v)?; + } + logical_plan_node::LogicalPlanType::Extension(v) => { + struct_ser.serialize_field("extension", v)?; + } + logical_plan_node::LogicalPlanType::CreateCatalogSchema(v) => { + struct_ser.serialize_field("createCatalogSchema", v)?; + } + logical_plan_node::LogicalPlanType::Union(v) => { + struct_ser.serialize_field("union", v)?; + } + logical_plan_node::LogicalPlanType::CreateCatalog(v) => { + struct_ser.serialize_field("createCatalog", v)?; + } + logical_plan_node::LogicalPlanType::SubqueryAlias(v) => { + struct_ser.serialize_field("subqueryAlias", v)?; + } + logical_plan_node::LogicalPlanType::CreateView(v) => { + struct_ser.serialize_field("createView", v)?; + } + logical_plan_node::LogicalPlanType::Distinct(v) => { + struct_ser.serialize_field("distinct", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalPlanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "listingScan", + "projection", + "selection", + "limit", + "aggregate", + "join", + "sort", + "repartition", + "emptyRelation", + "createExternalTable", + "explain", + "window", + "analyze", + "crossJoin", + "values", + "extension", + "createCatalogSchema", + "union", + "createCatalog", + "subqueryAlias", + "createView", + "distinct", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ListingScan, + Projection, + Selection, + Limit, + Aggregate, + Join, + Sort, + Repartition, + EmptyRelation, + CreateExternalTable, + Explain, + Window, + Analyze, + CrossJoin, + Values, + Extension, + CreateCatalogSchema, + Union, + CreateCatalog, + SubqueryAlias, + CreateView, + Distinct, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "listingScan" => Ok(GeneratedField::ListingScan), + "projection" => Ok(GeneratedField::Projection), + "selection" => Ok(GeneratedField::Selection), + "limit" => Ok(GeneratedField::Limit), + "aggregate" => Ok(GeneratedField::Aggregate), + "join" => Ok(GeneratedField::Join), + "sort" => Ok(GeneratedField::Sort), + "repartition" => Ok(GeneratedField::Repartition), + "emptyRelation" => Ok(GeneratedField::EmptyRelation), + "createExternalTable" => Ok(GeneratedField::CreateExternalTable), + "explain" => Ok(GeneratedField::Explain), + "window" => Ok(GeneratedField::Window), + "analyze" => Ok(GeneratedField::Analyze), + "crossJoin" => Ok(GeneratedField::CrossJoin), + "values" => Ok(GeneratedField::Values), + "extension" => Ok(GeneratedField::Extension), + "createCatalogSchema" => Ok(GeneratedField::CreateCatalogSchema), + "union" => Ok(GeneratedField::Union), + "createCatalog" => Ok(GeneratedField::CreateCatalog), + "subqueryAlias" => Ok(GeneratedField::SubqueryAlias), + "createView" => Ok(GeneratedField::CreateView), + "distinct" => Ok(GeneratedField::Distinct), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalPlanNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalPlanNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut logical_plan_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ListingScan => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("listingScan")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::ListingScan(map.next_value()?)); + } + GeneratedField::Projection => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Projection(map.next_value()?)); + } + GeneratedField::Selection => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("selection")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Selection(map.next_value()?)); + } + GeneratedField::Limit => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("limit")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Limit(map.next_value()?)); + } + GeneratedField::Aggregate => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregate")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Aggregate(map.next_value()?)); + } + GeneratedField::Join => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("join")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Join(map.next_value()?)); + } + GeneratedField::Sort => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sort")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Sort(map.next_value()?)); + } + GeneratedField::Repartition => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("repartition")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Repartition(map.next_value()?)); + } + GeneratedField::EmptyRelation => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("emptyRelation")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::EmptyRelation(map.next_value()?)); + } + GeneratedField::CreateExternalTable => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createExternalTable")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateExternalTable(map.next_value()?)); + } + GeneratedField::Explain => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("explain")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Explain(map.next_value()?)); + } + GeneratedField::Window => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("window")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Window(map.next_value()?)); + } + GeneratedField::Analyze => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("analyze")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Analyze(map.next_value()?)); + } + GeneratedField::CrossJoin => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("crossJoin")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CrossJoin(map.next_value()?)); + } + GeneratedField::Values => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("values")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Values(map.next_value()?)); + } + GeneratedField::Extension => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("extension")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Extension(map.next_value()?)); + } + GeneratedField::CreateCatalogSchema => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createCatalogSchema")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateCatalogSchema(map.next_value()?)); + } + GeneratedField::Union => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("union")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Union(map.next_value()?)); + } + GeneratedField::CreateCatalog => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createCatalog")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateCatalog(map.next_value()?)); + } + GeneratedField::SubqueryAlias => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("subqueryAlias")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::SubqueryAlias(map.next_value()?)); + } + GeneratedField::CreateView => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createView")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateView(map.next_value()?)); + } + GeneratedField::Distinct => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("distinct")); + } + logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Distinct(map.next_value()?)); + } + } + } + Ok(LogicalPlanNode { + logical_plan_type: logical_plan_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for NegativeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.NegativeNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for NegativeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = NegativeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.NegativeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(NegativeNode { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.NegativeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Not { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Not", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Not { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Not; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Not") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(Not { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.Not", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for OptimizedLogicalPlanType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.optimizer_name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedLogicalPlanType", len)?; + if !self.optimizer_name.is_empty() { + struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "optimizerName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OptimizerName, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "optimizerName" => Ok(GeneratedField::OptimizerName), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = OptimizedLogicalPlanType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.OptimizedLogicalPlanType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut optimizer_name__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::OptimizerName => { + if optimizer_name__.is_some() { + return Err(serde::de::Error::duplicate_field("optimizerName")); + } + optimizer_name__ = Some(map.next_value()?); + } + } + } + Ok(OptimizedLogicalPlanType { + optimizer_name: optimizer_name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.OptimizedLogicalPlanType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for OptimizedPhysicalPlanType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.optimizer_name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedPhysicalPlanType", len)?; + if !self.optimizer_name.is_empty() { + struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "optimizerName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OptimizerName, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "optimizerName" => Ok(GeneratedField::OptimizerName), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = OptimizedPhysicalPlanType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.OptimizedPhysicalPlanType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut optimizer_name__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::OptimizerName => { + if optimizer_name__.is_some() { + return Err(serde::de::Error::duplicate_field("optimizerName")); + } + optimizer_name__ = Some(map.next_value()?); + } + } + } + Ok(OptimizedPhysicalPlanType { + optimizer_name: optimizer_name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.OptimizedPhysicalPlanType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ParquetFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.enable_pruning { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?; + if self.enable_pruning { + struct_ser.serialize_field("enablePruning", &self.enable_pruning)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ParquetFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "enablePruning", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EnablePruning, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "enablePruning" => Ok(GeneratedField::EnablePruning), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ParquetFormat; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ParquetFormat") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut enable_pruning__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::EnablePruning => { + if enable_pruning__.is_some() { + return Err(serde::de::Error::duplicate_field("enablePruning")); + } + enable_pruning__ = Some(map.next_value()?); + } + } + } + Ok(ParquetFormat { + enable_pruning: enable_pruning__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ParquetFormat", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PlanType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.plan_type_enum.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PlanType", len)?; + if let Some(v) = self.plan_type_enum.as_ref() { + match v { + plan_type::PlanTypeEnum::InitialLogicalPlan(v) => { + struct_ser.serialize_field("InitialLogicalPlan", v)?; + } + plan_type::PlanTypeEnum::OptimizedLogicalPlan(v) => { + struct_ser.serialize_field("OptimizedLogicalPlan", v)?; + } + plan_type::PlanTypeEnum::FinalLogicalPlan(v) => { + struct_ser.serialize_field("FinalLogicalPlan", v)?; + } + plan_type::PlanTypeEnum::InitialPhysicalPlan(v) => { + struct_ser.serialize_field("InitialPhysicalPlan", v)?; + } + plan_type::PlanTypeEnum::OptimizedPhysicalPlan(v) => { + struct_ser.serialize_field("OptimizedPhysicalPlan", v)?; + } + plan_type::PlanTypeEnum::FinalPhysicalPlan(v) => { + struct_ser.serialize_field("FinalPhysicalPlan", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PlanType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "InitialLogicalPlan", + "OptimizedLogicalPlan", + "FinalLogicalPlan", + "InitialPhysicalPlan", + "OptimizedPhysicalPlan", + "FinalPhysicalPlan", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + InitialLogicalPlan, + OptimizedLogicalPlan, + FinalLogicalPlan, + InitialPhysicalPlan, + OptimizedPhysicalPlan, + FinalPhysicalPlan, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "InitialLogicalPlan" => Ok(GeneratedField::InitialLogicalPlan), + "OptimizedLogicalPlan" => Ok(GeneratedField::OptimizedLogicalPlan), + "FinalLogicalPlan" => Ok(GeneratedField::FinalLogicalPlan), + "InitialPhysicalPlan" => Ok(GeneratedField::InitialPhysicalPlan), + "OptimizedPhysicalPlan" => Ok(GeneratedField::OptimizedPhysicalPlan), + "FinalPhysicalPlan" => Ok(GeneratedField::FinalPhysicalPlan), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PlanType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PlanType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut plan_type_enum__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::InitialLogicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("InitialLogicalPlan")); + } + plan_type_enum__ = Some(plan_type::PlanTypeEnum::InitialLogicalPlan(map.next_value()?)); + } + GeneratedField::OptimizedLogicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("OptimizedLogicalPlan")); + } + plan_type_enum__ = Some(plan_type::PlanTypeEnum::OptimizedLogicalPlan(map.next_value()?)); + } + GeneratedField::FinalLogicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FinalLogicalPlan")); + } + plan_type_enum__ = Some(plan_type::PlanTypeEnum::FinalLogicalPlan(map.next_value()?)); + } + GeneratedField::InitialPhysicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan")); + } + plan_type_enum__ = Some(plan_type::PlanTypeEnum::InitialPhysicalPlan(map.next_value()?)); + } + GeneratedField::OptimizedPhysicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan")); + } + plan_type_enum__ = Some(plan_type::PlanTypeEnum::OptimizedPhysicalPlan(map.next_value()?)); + } + GeneratedField::FinalPhysicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan")); + } + plan_type_enum__ = Some(plan_type::PlanTypeEnum::FinalPhysicalPlan(map.next_value()?)); + } + } + } + Ok(PlanType { + plan_type_enum: plan_type_enum__, + }) + } + } + deserializer.deserialize_struct("datafusion.PlanType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PrimitiveScalarType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Bool => "BOOL", + Self::Uint8 => "UINT8", + Self::Int8 => "INT8", + Self::Uint16 => "UINT16", + Self::Int16 => "INT16", + Self::Uint32 => "UINT32", + Self::Int32 => "INT32", + Self::Uint64 => "UINT64", + Self::Int64 => "INT64", + Self::Float32 => "FLOAT32", + Self::Float64 => "FLOAT64", + Self::Utf8 => "UTF8", + Self::LargeUtf8 => "LARGE_UTF8", + Self::Date32 => "DATE32", + Self::TimeMicrosecond => "TIME_MICROSECOND", + Self::TimeNanosecond => "TIME_NANOSECOND", + Self::Null => "NULL", + Self::Decimal128 => "DECIMAL128", + Self::Date64 => "DATE64", + Self::TimeSecond => "TIME_SECOND", + Self::TimeMillisecond => "TIME_MILLISECOND", + Self::IntervalYearmonth => "INTERVAL_YEARMONTH", + Self::IntervalDaytime => "INTERVAL_DAYTIME", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for PrimitiveScalarType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "BOOL", + "UINT8", + "INT8", + "UINT16", + "INT16", + "UINT32", + "INT32", + "UINT64", + "INT64", + "FLOAT32", + "FLOAT64", + "UTF8", + "LARGE_UTF8", + "DATE32", + "TIME_MICROSECOND", + "TIME_NANOSECOND", + "NULL", + "DECIMAL128", + "DATE64", + "TIME_SECOND", + "TIME_MILLISECOND", + "INTERVAL_YEARMONTH", + "INTERVAL_DAYTIME", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PrimitiveScalarType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(PrimitiveScalarType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(PrimitiveScalarType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "BOOL" => Ok(PrimitiveScalarType::Bool), + "UINT8" => Ok(PrimitiveScalarType::Uint8), + "INT8" => Ok(PrimitiveScalarType::Int8), + "UINT16" => Ok(PrimitiveScalarType::Uint16), + "INT16" => Ok(PrimitiveScalarType::Int16), + "UINT32" => Ok(PrimitiveScalarType::Uint32), + "INT32" => Ok(PrimitiveScalarType::Int32), + "UINT64" => Ok(PrimitiveScalarType::Uint64), + "INT64" => Ok(PrimitiveScalarType::Int64), + "FLOAT32" => Ok(PrimitiveScalarType::Float32), + "FLOAT64" => Ok(PrimitiveScalarType::Float64), + "UTF8" => Ok(PrimitiveScalarType::Utf8), + "LARGE_UTF8" => Ok(PrimitiveScalarType::LargeUtf8), + "DATE32" => Ok(PrimitiveScalarType::Date32), + "TIME_MICROSECOND" => Ok(PrimitiveScalarType::TimeMicrosecond), + "TIME_NANOSECOND" => Ok(PrimitiveScalarType::TimeNanosecond), + "NULL" => Ok(PrimitiveScalarType::Null), + "DECIMAL128" => Ok(PrimitiveScalarType::Decimal128), + "DATE64" => Ok(PrimitiveScalarType::Date64), + "TIME_SECOND" => Ok(PrimitiveScalarType::TimeSecond), + "TIME_MILLISECOND" => Ok(PrimitiveScalarType::TimeMillisecond), + "INTERVAL_YEARMONTH" => Ok(PrimitiveScalarType::IntervalYearmonth), + "INTERVAL_DAYTIME" => Ok(PrimitiveScalarType::IntervalDaytime), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ProjectionColumns { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.columns.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionColumns", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ProjectionColumns { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "columns", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Columns, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "columns" => Ok(GeneratedField::Columns), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProjectionColumns; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ProjectionColumns") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut columns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); + } + columns__ = Some(map.next_value()?); + } + } + } + Ok(ProjectionColumns { + columns: columns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ProjectionColumns", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ProjectionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if self.optional_alias.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if let Some(v) = self.optional_alias.as_ref() { + match v { + projection_node::OptionalAlias::Alias(v) => { + struct_ser.serialize_field("alias", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ProjectionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + "alias", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + Alias, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + "alias" => Ok(GeneratedField::Alias), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProjectionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ProjectionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + let mut optional_alias__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Alias => { + if optional_alias__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + optional_alias__ = Some(projection_node::OptionalAlias::Alias(map.next_value()?)); + } + } + } + Ok(ProjectionNode { + input: input__, + expr: expr__.unwrap_or_default(), + optional_alias: optional_alias__, + }) + } + } + deserializer.deserialize_struct("datafusion.ProjectionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for RepartitionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.partition_method.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.partition_method.as_ref() { + match v { + repartition_node::PartitionMethod::RoundRobin(v) => { + struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?; + } + repartition_node::PartitionMethod::Hash(v) => { + struct_ser.serialize_field("hash", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RepartitionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "roundRobin", + "hash", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + RoundRobin, + Hash, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "roundRobin" => Ok(GeneratedField::RoundRobin), + "hash" => Ok(GeneratedField::Hash), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RepartitionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.RepartitionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut partition_method__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::RoundRobin => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("roundRobin")); + } + partition_method__ = Some(repartition_node::PartitionMethod::RoundRobin( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Hash => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("hash")); + } + partition_method__ = Some(repartition_node::PartitionMethod::Hash(map.next_value()?)); + } + } + } + Ok(RepartitionNode { + input: input__, + partition_method: partition_method__, + }) + } + } + deserializer.deserialize_struct("datafusion.RepartitionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for RollupNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.RollupNode", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RollupNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RollupNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.RollupNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(RollupNode { + expr: expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.RollupNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarDictionaryValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.index_type.is_some() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarDictionaryValue", len)?; + if let Some(v) = self.index_type.as_ref() { + struct_ser.serialize_field("indexType", v)?; + } + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "indexType", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IndexType, + Value, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "indexType" => Ok(GeneratedField::IndexType), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarDictionaryValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarDictionaryValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut index_type__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IndexType => { + if index_type__.is_some() { + return Err(serde::de::Error::duplicate_field("indexType")); + } + index_type__ = Some(map.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some(map.next_value()?); + } + } + } + Ok(ScalarDictionaryValue { + index_type: index_type__, + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarFunction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Abs => "Abs", + Self::Acos => "Acos", + Self::Asin => "Asin", + Self::Atan => "Atan", + Self::Ascii => "Ascii", + Self::Ceil => "Ceil", + Self::Cos => "Cos", + Self::Digest => "Digest", + Self::Exp => "Exp", + Self::Floor => "Floor", + Self::Ln => "Ln", + Self::Log => "Log", + Self::Log10 => "Log10", + Self::Log2 => "Log2", + Self::Round => "Round", + Self::Signum => "Signum", + Self::Sin => "Sin", + Self::Sqrt => "Sqrt", + Self::Tan => "Tan", + Self::Trunc => "Trunc", + Self::Array => "Array", + Self::RegexpMatch => "RegexpMatch", + Self::BitLength => "BitLength", + Self::Btrim => "Btrim", + Self::CharacterLength => "CharacterLength", + Self::Chr => "Chr", + Self::Concat => "Concat", + Self::ConcatWithSeparator => "ConcatWithSeparator", + Self::DatePart => "DatePart", + Self::DateTrunc => "DateTrunc", + Self::InitCap => "InitCap", + Self::Left => "Left", + Self::Lpad => "Lpad", + Self::Lower => "Lower", + Self::Ltrim => "Ltrim", + Self::Md5 => "MD5", + Self::NullIf => "NullIf", + Self::OctetLength => "OctetLength", + Self::Random => "Random", + Self::RegexpReplace => "RegexpReplace", + Self::Repeat => "Repeat", + Self::Replace => "Replace", + Self::Reverse => "Reverse", + Self::Right => "Right", + Self::Rpad => "Rpad", + Self::Rtrim => "Rtrim", + Self::Sha224 => "SHA224", + Self::Sha256 => "SHA256", + Self::Sha384 => "SHA384", + Self::Sha512 => "SHA512", + Self::SplitPart => "SplitPart", + Self::StartsWith => "StartsWith", + Self::Strpos => "Strpos", + Self::Substr => "Substr", + Self::ToHex => "ToHex", + Self::ToTimestamp => "ToTimestamp", + Self::ToTimestampMillis => "ToTimestampMillis", + Self::ToTimestampMicros => "ToTimestampMicros", + Self::ToTimestampSeconds => "ToTimestampSeconds", + Self::Now => "Now", + Self::Translate => "Translate", + Self::Trim => "Trim", + Self::Upper => "Upper", + Self::Coalesce => "Coalesce", + Self::Power => "Power", + Self::StructFun => "StructFun", + Self::FromUnixtime => "FromUnixtime", + Self::Atan2 => "Atan2", + Self::DateBin => "DateBin", + Self::ArrowTypeof => "ArrowTypeof", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ScalarFunction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "Abs", + "Acos", + "Asin", + "Atan", + "Ascii", + "Ceil", + "Cos", + "Digest", + "Exp", + "Floor", + "Ln", + "Log", + "Log10", + "Log2", + "Round", + "Signum", + "Sin", + "Sqrt", + "Tan", + "Trunc", + "Array", + "RegexpMatch", + "BitLength", + "Btrim", + "CharacterLength", + "Chr", + "Concat", + "ConcatWithSeparator", + "DatePart", + "DateTrunc", + "InitCap", + "Left", + "Lpad", + "Lower", + "Ltrim", + "MD5", + "NullIf", + "OctetLength", + "Random", + "RegexpReplace", + "Repeat", + "Replace", + "Reverse", + "Right", + "Rpad", + "Rtrim", + "SHA224", + "SHA256", + "SHA384", + "SHA512", + "SplitPart", + "StartsWith", + "Strpos", + "Substr", + "ToHex", + "ToTimestamp", + "ToTimestampMillis", + "ToTimestampMicros", + "ToTimestampSeconds", + "Now", + "Translate", + "Trim", + "Upper", + "Coalesce", + "Power", + "StructFun", + "FromUnixtime", + "Atan2", + "DateBin", + "ArrowTypeof", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarFunction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(ScalarFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(ScalarFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "Abs" => Ok(ScalarFunction::Abs), + "Acos" => Ok(ScalarFunction::Acos), + "Asin" => Ok(ScalarFunction::Asin), + "Atan" => Ok(ScalarFunction::Atan), + "Ascii" => Ok(ScalarFunction::Ascii), + "Ceil" => Ok(ScalarFunction::Ceil), + "Cos" => Ok(ScalarFunction::Cos), + "Digest" => Ok(ScalarFunction::Digest), + "Exp" => Ok(ScalarFunction::Exp), + "Floor" => Ok(ScalarFunction::Floor), + "Ln" => Ok(ScalarFunction::Ln), + "Log" => Ok(ScalarFunction::Log), + "Log10" => Ok(ScalarFunction::Log10), + "Log2" => Ok(ScalarFunction::Log2), + "Round" => Ok(ScalarFunction::Round), + "Signum" => Ok(ScalarFunction::Signum), + "Sin" => Ok(ScalarFunction::Sin), + "Sqrt" => Ok(ScalarFunction::Sqrt), + "Tan" => Ok(ScalarFunction::Tan), + "Trunc" => Ok(ScalarFunction::Trunc), + "Array" => Ok(ScalarFunction::Array), + "RegexpMatch" => Ok(ScalarFunction::RegexpMatch), + "BitLength" => Ok(ScalarFunction::BitLength), + "Btrim" => Ok(ScalarFunction::Btrim), + "CharacterLength" => Ok(ScalarFunction::CharacterLength), + "Chr" => Ok(ScalarFunction::Chr), + "Concat" => Ok(ScalarFunction::Concat), + "ConcatWithSeparator" => Ok(ScalarFunction::ConcatWithSeparator), + "DatePart" => Ok(ScalarFunction::DatePart), + "DateTrunc" => Ok(ScalarFunction::DateTrunc), + "InitCap" => Ok(ScalarFunction::InitCap), + "Left" => Ok(ScalarFunction::Left), + "Lpad" => Ok(ScalarFunction::Lpad), + "Lower" => Ok(ScalarFunction::Lower), + "Ltrim" => Ok(ScalarFunction::Ltrim), + "MD5" => Ok(ScalarFunction::Md5), + "NullIf" => Ok(ScalarFunction::NullIf), + "OctetLength" => Ok(ScalarFunction::OctetLength), + "Random" => Ok(ScalarFunction::Random), + "RegexpReplace" => Ok(ScalarFunction::RegexpReplace), + "Repeat" => Ok(ScalarFunction::Repeat), + "Replace" => Ok(ScalarFunction::Replace), + "Reverse" => Ok(ScalarFunction::Reverse), + "Right" => Ok(ScalarFunction::Right), + "Rpad" => Ok(ScalarFunction::Rpad), + "Rtrim" => Ok(ScalarFunction::Rtrim), + "SHA224" => Ok(ScalarFunction::Sha224), + "SHA256" => Ok(ScalarFunction::Sha256), + "SHA384" => Ok(ScalarFunction::Sha384), + "SHA512" => Ok(ScalarFunction::Sha512), + "SplitPart" => Ok(ScalarFunction::SplitPart), + "StartsWith" => Ok(ScalarFunction::StartsWith), + "Strpos" => Ok(ScalarFunction::Strpos), + "Substr" => Ok(ScalarFunction::Substr), + "ToHex" => Ok(ScalarFunction::ToHex), + "ToTimestamp" => Ok(ScalarFunction::ToTimestamp), + "ToTimestampMillis" => Ok(ScalarFunction::ToTimestampMillis), + "ToTimestampMicros" => Ok(ScalarFunction::ToTimestampMicros), + "ToTimestampSeconds" => Ok(ScalarFunction::ToTimestampSeconds), + "Now" => Ok(ScalarFunction::Now), + "Translate" => Ok(ScalarFunction::Translate), + "Trim" => Ok(ScalarFunction::Trim), + "Upper" => Ok(ScalarFunction::Upper), + "Coalesce" => Ok(ScalarFunction::Coalesce), + "Power" => Ok(ScalarFunction::Power), + "StructFun" => Ok(ScalarFunction::StructFun), + "FromUnixtime" => Ok(ScalarFunction::FromUnixtime), + "Atan2" => Ok(ScalarFunction::Atan2), + "DateBin" => Ok(ScalarFunction::DateBin), + "ArrowTypeof" => Ok(ScalarFunction::ArrowTypeof), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ScalarFunctionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.fun != 0 { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFunctionNode", len)?; + if self.fun != 0 { + let v = ScalarFunction::from_i32(self.fun) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?; + struct_ser.serialize_field("fun", &v)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fun", + "args", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Fun, + Args, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fun" => Ok(GeneratedField::Fun), + "args" => Ok(GeneratedField::Args), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarFunctionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarFunctionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fun__ = None; + let mut args__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Fun => { + if fun__.is_some() { + return Err(serde::de::Error::duplicate_field("fun")); + } + fun__ = Some(map.next_value::()? as i32); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + } + } + Ok(ScalarFunctionNode { + fun: fun__.unwrap_or_default(), + args: args__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarFunctionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarListType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.field_names.is_empty() { + len += 1; + } + if self.deepest_type != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListType", len)?; + if !self.field_names.is_empty() { + struct_ser.serialize_field("fieldNames", &self.field_names)?; + } + if self.deepest_type != 0 { + let v = PrimitiveScalarType::from_i32(self.deepest_type) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.deepest_type)))?; + struct_ser.serialize_field("deepestType", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarListType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fieldNames", + "deepestType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FieldNames, + DeepestType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fieldNames" => Ok(GeneratedField::FieldNames), + "deepestType" => Ok(GeneratedField::DeepestType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarListType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarListType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field_names__ = None; + let mut deepest_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FieldNames => { + if field_names__.is_some() { + return Err(serde::de::Error::duplicate_field("fieldNames")); + } + field_names__ = Some(map.next_value()?); + } + GeneratedField::DeepestType => { + if deepest_type__.is_some() { + return Err(serde::de::Error::duplicate_field("deepestType")); + } + deepest_type__ = Some(map.next_value::()? as i32); + } + } + } + Ok(ScalarListType { + field_names: field_names__.unwrap_or_default(), + deepest_type: deepest_type__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarListType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarListValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.field.is_some() { + len += 1; + } + if !self.values.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListValue", len)?; + if let Some(v) = self.field.as_ref() { + struct_ser.serialize_field("field", v)?; + } + if !self.values.is_empty() { + struct_ser.serialize_field("values", &self.values)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarListValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "field", + "values", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Field, + Values, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "field" => Ok(GeneratedField::Field), + "values" => Ok(GeneratedField::Values), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarListValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarListValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field__ = None; + let mut values__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Field => { + if field__.is_some() { + return Err(serde::de::Error::duplicate_field("field")); + } + field__ = Some(map.next_value()?); + } + GeneratedField::Values => { + if values__.is_some() { + return Err(serde::de::Error::duplicate_field("values")); + } + values__ = Some(map.next_value()?); + } + } + } + Ok(ScalarListValue { + field: field__, + values: values__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarListValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarTimestampValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.timezone.is_empty() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?; + if !self.timezone.is_empty() { + struct_ser.serialize_field("timezone", &self.timezone)?; + } + if let Some(v) = self.value.as_ref() { + match v { + scalar_timestamp_value::Value::TimeMicrosecondValue(v) => { + struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeNanosecondValue(v) => { + struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeSecondValue(v) => { + struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeMillisecondValue(v) => { + struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timezone", + "timeMicrosecondValue", + "timeNanosecondValue", + "timeSecondValue", + "timeMillisecondValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Timezone, + TimeMicrosecondValue, + TimeNanosecondValue, + TimeSecondValue, + TimeMillisecondValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timezone" => Ok(GeneratedField::Timezone), + "timeMicrosecondValue" => Ok(GeneratedField::TimeMicrosecondValue), + "timeNanosecondValue" => Ok(GeneratedField::TimeNanosecondValue), + "timeSecondValue" => Ok(GeneratedField::TimeSecondValue), + "timeMillisecondValue" => Ok(GeneratedField::TimeMillisecondValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarTimestampValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarTimestampValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timezone__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Timezone => { + if timezone__.is_some() { + return Err(serde::de::Error::duplicate_field("timezone")); + } + timezone__ = Some(map.next_value()?); + } + GeneratedField::TimeMicrosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeMicrosecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeMicrosecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimeNanosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeNanosecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeNanosecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimeSecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeSecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeSecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimeMillisecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeMillisecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeMillisecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + } + } + Ok(ScalarTimestampValue { + timezone: timezone__.unwrap_or_default(), + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.datatype.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarType", len)?; + if let Some(v) = self.datatype.as_ref() { + match v { + scalar_type::Datatype::Scalar(v) => { + let v = PrimitiveScalarType::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("scalar", &v)?; + } + scalar_type::Datatype::List(v) => { + struct_ser.serialize_field("list", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "scalar", + "list", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Scalar, + List, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "scalar" => Ok(GeneratedField::Scalar), + "list" => Ok(GeneratedField::List), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut datatype__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Scalar => { + if datatype__.is_some() { + return Err(serde::de::Error::duplicate_field("scalar")); + } + datatype__ = Some(scalar_type::Datatype::Scalar(map.next_value::()? as i32)); + } + GeneratedField::List => { + if datatype__.is_some() { + return Err(serde::de::Error::duplicate_field("list")); + } + datatype__ = Some(scalar_type::Datatype::List(map.next_value()?)); + } + } + } + Ok(ScalarType { + datatype: datatype__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarUdfExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.fun_name.is_empty() { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?; + if !self.fun_name.is_empty() { + struct_ser.serialize_field("funName", &self.fun_name)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "funName", + "args", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FunName, + Args, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "funName" => Ok(GeneratedField::FunName), + "args" => Ok(GeneratedField::Args), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarUdfExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarUDFExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fun_name__ = None; + let mut args__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FunName => { + if fun_name__.is_some() { + return Err(serde::de::Error::duplicate_field("funName")); + } + fun_name__ = Some(map.next_value()?); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + } + } + Ok(ScalarUdfExprNode { + fun_name: fun_name__.unwrap_or_default(), + args: args__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?; + if let Some(v) = self.value.as_ref() { + match v { + scalar_value::Value::BoolValue(v) => { + struct_ser.serialize_field("boolValue", v)?; + } + scalar_value::Value::Utf8Value(v) => { + struct_ser.serialize_field("utf8Value", v)?; + } + scalar_value::Value::LargeUtf8Value(v) => { + struct_ser.serialize_field("largeUtf8Value", v)?; + } + scalar_value::Value::Int8Value(v) => { + struct_ser.serialize_field("int8Value", v)?; + } + scalar_value::Value::Int16Value(v) => { + struct_ser.serialize_field("int16Value", v)?; + } + scalar_value::Value::Int32Value(v) => { + struct_ser.serialize_field("int32Value", v)?; + } + scalar_value::Value::Int64Value(v) => { + struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::Uint8Value(v) => { + struct_ser.serialize_field("uint8Value", v)?; + } + scalar_value::Value::Uint16Value(v) => { + struct_ser.serialize_field("uint16Value", v)?; + } + scalar_value::Value::Uint32Value(v) => { + struct_ser.serialize_field("uint32Value", v)?; + } + scalar_value::Value::Uint64Value(v) => { + struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::Float32Value(v) => { + struct_ser.serialize_field("float32Value", v)?; + } + scalar_value::Value::Float64Value(v) => { + struct_ser.serialize_field("float64Value", v)?; + } + scalar_value::Value::Date32Value(v) => { + struct_ser.serialize_field("date32Value", v)?; + } + scalar_value::Value::ListValue(v) => { + struct_ser.serialize_field("listValue", v)?; + } + scalar_value::Value::NullListValue(v) => { + struct_ser.serialize_field("nullListValue", v)?; + } + scalar_value::Value::NullValue(v) => { + let v = PrimitiveScalarType::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("nullValue", &v)?; + } + scalar_value::Value::Decimal128Value(v) => { + struct_ser.serialize_field("decimal128Value", v)?; + } + scalar_value::Value::Date64Value(v) => { + struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::IntervalYearmonthValue(v) => { + struct_ser.serialize_field("intervalYearmonthValue", v)?; + } + scalar_value::Value::IntervalDaytimeValue(v) => { + struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::TimestampValue(v) => { + struct_ser.serialize_field("timestampValue", v)?; + } + scalar_value::Value::DictionaryValue(v) => { + struct_ser.serialize_field("dictionaryValue", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "boolValue", + "utf8Value", + "largeUtf8Value", + "int8Value", + "int16Value", + "int32Value", + "int64Value", + "uint8Value", + "uint16Value", + "uint32Value", + "uint64Value", + "float32Value", + "float64Value", + "date32Value", + "listValue", + "nullListValue", + "nullValue", + "decimal128Value", + "date64Value", + "intervalYearmonthValue", + "intervalDaytimeValue", + "timestampValue", + "dictionaryValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + BoolValue, + Utf8Value, + LargeUtf8Value, + Int8Value, + Int16Value, + Int32Value, + Int64Value, + Uint8Value, + Uint16Value, + Uint32Value, + Uint64Value, + Float32Value, + Float64Value, + Date32Value, + ListValue, + NullListValue, + NullValue, + Decimal128Value, + Date64Value, + IntervalYearmonthValue, + IntervalDaytimeValue, + TimestampValue, + DictionaryValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "boolValue" => Ok(GeneratedField::BoolValue), + "utf8Value" => Ok(GeneratedField::Utf8Value), + "largeUtf8Value" => Ok(GeneratedField::LargeUtf8Value), + "int8Value" => Ok(GeneratedField::Int8Value), + "int16Value" => Ok(GeneratedField::Int16Value), + "int32Value" => Ok(GeneratedField::Int32Value), + "int64Value" => Ok(GeneratedField::Int64Value), + "uint8Value" => Ok(GeneratedField::Uint8Value), + "uint16Value" => Ok(GeneratedField::Uint16Value), + "uint32Value" => Ok(GeneratedField::Uint32Value), + "uint64Value" => Ok(GeneratedField::Uint64Value), + "float32Value" => Ok(GeneratedField::Float32Value), + "float64Value" => Ok(GeneratedField::Float64Value), + "date32Value" => Ok(GeneratedField::Date32Value), + "listValue" => Ok(GeneratedField::ListValue), + "nullListValue" => Ok(GeneratedField::NullListValue), + "nullValue" => Ok(GeneratedField::NullValue), + "decimal128Value" => Ok(GeneratedField::Decimal128Value), + "date64Value" => Ok(GeneratedField::Date64Value), + "intervalYearmonthValue" => Ok(GeneratedField::IntervalYearmonthValue), + "intervalDaytimeValue" => Ok(GeneratedField::IntervalDaytimeValue), + "timestampValue" => Ok(GeneratedField::TimestampValue), + "dictionaryValue" => Ok(GeneratedField::DictionaryValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::BoolValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("boolValue")); + } + value__ = Some(scalar_value::Value::BoolValue(map.next_value()?)); + } + GeneratedField::Utf8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("utf8Value")); + } + value__ = Some(scalar_value::Value::Utf8Value(map.next_value()?)); + } + GeneratedField::LargeUtf8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("largeUtf8Value")); + } + value__ = Some(scalar_value::Value::LargeUtf8Value(map.next_value()?)); + } + GeneratedField::Int8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int8Value")); + } + value__ = Some(scalar_value::Value::Int8Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Int16Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int16Value")); + } + value__ = Some(scalar_value::Value::Int16Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Int32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int32Value")); + } + value__ = Some(scalar_value::Value::Int32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Int64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int64Value")); + } + value__ = Some(scalar_value::Value::Int64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint8Value")); + } + value__ = Some(scalar_value::Value::Uint8Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint16Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint16Value")); + } + value__ = Some(scalar_value::Value::Uint16Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint32Value")); + } + value__ = Some(scalar_value::Value::Uint32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint64Value")); + } + value__ = Some(scalar_value::Value::Uint64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Float32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("float32Value")); + } + value__ = Some(scalar_value::Value::Float32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Float64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("float64Value")); + } + value__ = Some(scalar_value::Value::Float64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Date32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("date32Value")); + } + value__ = Some(scalar_value::Value::Date32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::ListValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("listValue")); + } + value__ = Some(scalar_value::Value::ListValue(map.next_value()?)); + } + GeneratedField::NullListValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("nullListValue")); + } + value__ = Some(scalar_value::Value::NullListValue(map.next_value()?)); + } + GeneratedField::NullValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("nullValue")); + } + value__ = Some(scalar_value::Value::NullValue(map.next_value::()? as i32)); + } + GeneratedField::Decimal128Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("decimal128Value")); + } + value__ = Some(scalar_value::Value::Decimal128Value(map.next_value()?)); + } + GeneratedField::Date64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("date64Value")); + } + value__ = Some(scalar_value::Value::Date64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::IntervalYearmonthValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalYearmonthValue")); + } + value__ = Some(scalar_value::Value::IntervalYearmonthValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::IntervalDaytimeValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalDaytimeValue")); + } + value__ = Some(scalar_value::Value::IntervalDaytimeValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimestampValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timestampValue")); + } + value__ = Some(scalar_value::Value::TimestampValue(map.next_value()?)); + } + GeneratedField::DictionaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("dictionaryValue")); + } + value__ = Some(scalar_value::Value::DictionaryValue(map.next_value()?)); + } + } + } + Ok(ScalarValue { + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Schema { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.columns.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Schema { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "columns", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Columns, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "columns" => Ok(GeneratedField::Columns), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Schema; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Schema") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut columns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); + } + columns__ = Some(map.next_value()?); + } + } + } + Ok(Schema { + columns: columns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SelectionExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SelectionExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SelectionExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SelectionExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(SelectionExecNode { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SelectionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SelectionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SelectionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SelectionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(SelectionNode { + input: input__, + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SimilarToNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.negated { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + if self.pattern.is_some() { + len += 1; + } + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SimilarToNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "negated", + "expr", + "pattern", + "escapeChar", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Negated, + Expr, + Pattern, + EscapeChar, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "negated" => Ok(GeneratedField::Negated), + "expr" => Ok(GeneratedField::Expr), + "pattern" => Ok(GeneratedField::Pattern), + "escapeChar" => Ok(GeneratedField::EscapeChar), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SimilarToNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SimilarToNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut negated__ = None; + let mut expr__ = None; + let mut pattern__ = None; + let mut escape_char__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Pattern => { + if pattern__.is_some() { + return Err(serde::de::Error::duplicate_field("pattern")); + } + pattern__ = Some(map.next_value()?); + } + GeneratedField::EscapeChar => { + if escape_char__.is_some() { + return Err(serde::de::Error::duplicate_field("escapeChar")); + } + escape_char__ = Some(map.next_value()?); + } + } + } + Ok(SimilarToNode { + negated: negated__.unwrap_or_default(), + expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SortExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.asc { + len += 1; + } + if self.nulls_first { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if self.asc { + struct_ser.serialize_field("asc", &self.asc)?; + } + if self.nulls_first { + struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SortExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "asc", + "nullsFirst", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Asc, + NullsFirst, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "asc" => Ok(GeneratedField::Asc), + "nullsFirst" => Ok(GeneratedField::NullsFirst), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SortExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SortExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut asc__ = None; + let mut nulls_first__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Asc => { + if asc__.is_some() { + return Err(serde::de::Error::duplicate_field("asc")); + } + asc__ = Some(map.next_value()?); + } + GeneratedField::NullsFirst => { + if nulls_first__.is_some() { + return Err(serde::de::Error::duplicate_field("nullsFirst")); + } + nulls_first__ = Some(map.next_value()?); + } + } + } + Ok(SortExprNode { + expr: expr__, + asc: asc__.unwrap_or_default(), + nulls_first: nulls_first__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SortNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SortNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + "fetch", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + Fetch, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + "fetch" => Ok(GeneratedField::Fetch), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SortNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SortNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + let mut fetch__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(SortNode { + input: input__, + expr: expr__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StringifiedPlan { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.plan_type.is_some() { + len += 1; + } + if !self.plan.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.StringifiedPlan", len)?; + if let Some(v) = self.plan_type.as_ref() { + struct_ser.serialize_field("planType", v)?; + } + if !self.plan.is_empty() { + struct_ser.serialize_field("plan", &self.plan)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StringifiedPlan { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "planType", + "plan", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PlanType, + Plan, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "planType" => Ok(GeneratedField::PlanType), + "plan" => Ok(GeneratedField::Plan), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StringifiedPlan; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.StringifiedPlan") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut plan_type__ = None; + let mut plan__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::PlanType => { + if plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("planType")); + } + plan_type__ = Some(map.next_value()?); + } + GeneratedField::Plan => { + if plan__.is_some() { + return Err(serde::de::Error::duplicate_field("plan")); + } + plan__ = Some(map.next_value()?); + } + } + } + Ok(StringifiedPlan { + plan_type: plan_type__, + plan: plan__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.StringifiedPlan", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Struct { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sub_field_types.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Struct", len)?; + if !self.sub_field_types.is_empty() { + struct_ser.serialize_field("subFieldTypes", &self.sub_field_types)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Struct { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "subFieldTypes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SubFieldTypes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "subFieldTypes" => Ok(GeneratedField::SubFieldTypes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Struct; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Struct") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sub_field_types__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::SubFieldTypes => { + if sub_field_types__.is_some() { + return Err(serde::de::Error::duplicate_field("subFieldTypes")); + } + sub_field_types__ = Some(map.next_value()?); + } + } + } + Ok(Struct { + sub_field_types: sub_field_types__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Struct", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SubqueryAliasNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.alias.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SubqueryAliasNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.alias.is_empty() { + struct_ser.serialize_field("alias", &self.alias)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SubqueryAliasNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "alias", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Alias, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "alias" => Ok(GeneratedField::Alias), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SubqueryAliasNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SubqueryAliasNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut alias__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Alias => { + if alias__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + alias__ = Some(map.next_value()?); + } + } + } + Ok(SubqueryAliasNode { + input: input__, + alias: alias__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SubqueryAliasNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TimeUnit { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Second => "Second", + Self::TimeMillisecond => "TimeMillisecond", + Self::Microsecond => "Microsecond", + Self::Nanosecond => "Nanosecond", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for TimeUnit { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "Second", + "TimeMillisecond", + "Microsecond", + "Nanosecond", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TimeUnit; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(TimeUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(TimeUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "Second" => Ok(TimeUnit::Second), + "TimeMillisecond" => Ok(TimeUnit::TimeMillisecond), + "Microsecond" => Ok(TimeUnit::Microsecond), + "Nanosecond" => Ok(TimeUnit::Nanosecond), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for Timestamp { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.time_unit != 0 { + len += 1; + } + if !self.timezone.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Timestamp", len)?; + if self.time_unit != 0 { + let v = TimeUnit::from_i32(self.time_unit) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.time_unit)))?; + struct_ser.serialize_field("timeUnit", &v)?; + } + if !self.timezone.is_empty() { + struct_ser.serialize_field("timezone", &self.timezone)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Timestamp { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timeUnit", + "timezone", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TimeUnit, + Timezone, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timeUnit" => Ok(GeneratedField::TimeUnit), + "timezone" => Ok(GeneratedField::Timezone), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Timestamp; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Timestamp") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut time_unit__ = None; + let mut timezone__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::TimeUnit => { + if time_unit__.is_some() { + return Err(serde::de::Error::duplicate_field("timeUnit")); + } + time_unit__ = Some(map.next_value::()? as i32); + } + GeneratedField::Timezone => { + if timezone__.is_some() { + return Err(serde::de::Error::duplicate_field("timezone")); + } + timezone__ = Some(map.next_value()?); + } + } + } + Ok(Timestamp { + time_unit: time_unit__.unwrap_or_default(), + timezone: timezone__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Timestamp", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TryCastNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.arrow_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.TryCastNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TryCastNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "arrowType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + ArrowType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "arrowType" => Ok(GeneratedField::ArrowType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TryCastNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.TryCastNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut arrow_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::ArrowType => { + if arrow_type__.is_some() { + return Err(serde::de::Error::duplicate_field("arrowType")); + } + arrow_type__ = Some(map.next_value()?); + } + } + } + Ok(TryCastNode { + expr: expr__, + arrow_type: arrow_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.TryCastNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Union { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.union_types.is_empty() { + len += 1; + } + if self.union_mode != 0 { + len += 1; + } + if !self.type_ids.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Union", len)?; + if !self.union_types.is_empty() { + struct_ser.serialize_field("unionTypes", &self.union_types)?; + } + if self.union_mode != 0 { + let v = UnionMode::from_i32(self.union_mode) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.union_mode)))?; + struct_ser.serialize_field("unionMode", &v)?; + } + if !self.type_ids.is_empty() { + struct_ser.serialize_field("typeIds", &self.type_ids)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Union { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "unionTypes", + "unionMode", + "typeIds", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + UnionTypes, + UnionMode, + TypeIds, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "unionTypes" => Ok(GeneratedField::UnionTypes), + "unionMode" => Ok(GeneratedField::UnionMode), + "typeIds" => Ok(GeneratedField::TypeIds), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Union; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Union") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut union_types__ = None; + let mut union_mode__ = None; + let mut type_ids__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::UnionTypes => { + if union_types__.is_some() { + return Err(serde::de::Error::duplicate_field("unionTypes")); + } + union_types__ = Some(map.next_value()?); + } + GeneratedField::UnionMode => { + if union_mode__.is_some() { + return Err(serde::de::Error::duplicate_field("unionMode")); + } + union_mode__ = Some(map.next_value::()? as i32); + } + GeneratedField::TypeIds => { + if type_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("typeIds")); + } + type_ids__ = Some( + map.next_value::>>()? + .into_iter().map(|x| x.0).collect() + ); + } + } + } + Ok(Union { + union_types: union_types__.unwrap_or_default(), + union_mode: union_mode__.unwrap_or_default(), + type_ids: type_ids__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnionMode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Sparse => "sparse", + Self::Dense => "dense", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for UnionMode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sparse", + "dense", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnionMode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(UnionMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(UnionMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sparse" => Ok(UnionMode::Sparse), + "dense" => Ok(UnionMode::Dense), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for UnionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.inputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.UnionNode", len)?; + if !self.inputs.is_empty() { + struct_ser.serialize_field("inputs", &self.inputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "inputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Inputs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "inputs" => Ok(GeneratedField::Inputs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.UnionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut inputs__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Inputs => { + if inputs__.is_some() { + return Err(serde::de::Error::duplicate_field("inputs")); + } + inputs__ = Some(map.next_value()?); + } + } + } + Ok(UnionNode { + inputs: inputs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ValuesNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.n_cols != 0 { + len += 1; + } + if !self.values_list.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ValuesNode", len)?; + if self.n_cols != 0 { + struct_ser.serialize_field("nCols", ToString::to_string(&self.n_cols).as_str())?; + } + if !self.values_list.is_empty() { + struct_ser.serialize_field("valuesList", &self.values_list)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ValuesNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "nCols", + "valuesList", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + NCols, + ValuesList, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "nCols" => Ok(GeneratedField::NCols), + "valuesList" => Ok(GeneratedField::ValuesList), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ValuesNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ValuesNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut n_cols__ = None; + let mut values_list__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::NCols => { + if n_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("nCols")); + } + n_cols__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + GeneratedField::ValuesList => { + if values_list__.is_some() { + return Err(serde::de::Error::duplicate_field("valuesList")); + } + values_list__ = Some(map.next_value()?); + } + } + } + Ok(ValuesNode { + n_cols: n_cols__.unwrap_or_default(), + values_list: values_list__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ValuesNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WhenThen { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.when_expr.is_some() { + len += 1; + } + if self.then_expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WhenThen", len)?; + if let Some(v) = self.when_expr.as_ref() { + struct_ser.serialize_field("whenExpr", v)?; + } + if let Some(v) = self.then_expr.as_ref() { + struct_ser.serialize_field("thenExpr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WhenThen { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "whenExpr", + "thenExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WhenExpr, + ThenExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "whenExpr" => Ok(GeneratedField::WhenExpr), + "thenExpr" => Ok(GeneratedField::ThenExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WhenThen; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WhenThen") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut when_expr__ = None; + let mut then_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WhenExpr => { + if when_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("whenExpr")); + } + when_expr__ = Some(map.next_value()?); + } + GeneratedField::ThenExpr => { + if then_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("thenExpr")); + } + then_expr__ = Some(map.next_value()?); + } + } + } + Ok(WhenThen { + when_expr: when_expr__, + then_expr: then_expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.WhenThen", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.partition_by.is_empty() { + len += 1; + } + if !self.order_by.is_empty() { + len += 1; + } + if self.window_function.is_some() { + len += 1; + } + if self.window_frame.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowExprNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.partition_by.is_empty() { + struct_ser.serialize_field("partitionBy", &self.partition_by)?; + } + if !self.order_by.is_empty() { + struct_ser.serialize_field("orderBy", &self.order_by)?; + } + if let Some(v) = self.window_function.as_ref() { + match v { + window_expr_node::WindowFunction::AggrFunction(v) => { + let v = AggregateFunction::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("aggrFunction", &v)?; + } + window_expr_node::WindowFunction::BuiltInFunction(v) => { + let v = BuiltInWindowFunction::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("builtInFunction", &v)?; + } + } + } + if let Some(v) = self.window_frame.as_ref() { + match v { + window_expr_node::WindowFrame::Frame(v) => { + struct_ser.serialize_field("frame", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "partitionBy", + "orderBy", + "aggrFunction", + "builtInFunction", + "frame", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + PartitionBy, + OrderBy, + AggrFunction, + BuiltInFunction, + Frame, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "partitionBy" => Ok(GeneratedField::PartitionBy), + "orderBy" => Ok(GeneratedField::OrderBy), + "aggrFunction" => Ok(GeneratedField::AggrFunction), + "builtInFunction" => Ok(GeneratedField::BuiltInFunction), + "frame" => Ok(GeneratedField::Frame), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut partition_by__ = None; + let mut order_by__ = None; + let mut window_function__ = None; + let mut window_frame__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::PartitionBy => { + if partition_by__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionBy")); + } + partition_by__ = Some(map.next_value()?); + } + GeneratedField::OrderBy => { + if order_by__.is_some() { + return Err(serde::de::Error::duplicate_field("orderBy")); + } + order_by__ = Some(map.next_value()?); + } + GeneratedField::AggrFunction => { + if window_function__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrFunction")); + } + window_function__ = Some(window_expr_node::WindowFunction::AggrFunction(map.next_value::()? as i32)); + } + GeneratedField::BuiltInFunction => { + if window_function__.is_some() { + return Err(serde::de::Error::duplicate_field("builtInFunction")); + } + window_function__ = Some(window_expr_node::WindowFunction::BuiltInFunction(map.next_value::()? as i32)); + } + GeneratedField::Frame => { + if window_frame__.is_some() { + return Err(serde::de::Error::duplicate_field("frame")); + } + window_frame__ = Some(window_expr_node::WindowFrame::Frame(map.next_value()?)); + } + } + } + Ok(WindowExprNode { + expr: expr__, + partition_by: partition_by__.unwrap_or_default(), + order_by: order_by__.unwrap_or_default(), + window_function: window_function__, + window_frame: window_frame__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrame { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.window_frame_units != 0 { + len += 1; + } + if self.start_bound.is_some() { + len += 1; + } + if self.end_bound.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrame", len)?; + if self.window_frame_units != 0 { + let v = WindowFrameUnits::from_i32(self.window_frame_units) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_units)))?; + struct_ser.serialize_field("windowFrameUnits", &v)?; + } + if let Some(v) = self.start_bound.as_ref() { + struct_ser.serialize_field("startBound", v)?; + } + if let Some(v) = self.end_bound.as_ref() { + match v { + window_frame::EndBound::Bound(v) => { + struct_ser.serialize_field("bound", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowFrame { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "windowFrameUnits", + "startBound", + "bound", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WindowFrameUnits, + StartBound, + Bound, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "windowFrameUnits" => Ok(GeneratedField::WindowFrameUnits), + "startBound" => Ok(GeneratedField::StartBound), + "bound" => Ok(GeneratedField::Bound), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrame; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowFrame") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut window_frame_units__ = None; + let mut start_bound__ = None; + let mut end_bound__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WindowFrameUnits => { + if window_frame_units__.is_some() { + return Err(serde::de::Error::duplicate_field("windowFrameUnits")); + } + window_frame_units__ = Some(map.next_value::()? as i32); + } + GeneratedField::StartBound => { + if start_bound__.is_some() { + return Err(serde::de::Error::duplicate_field("startBound")); + } + start_bound__ = Some(map.next_value()?); + } + GeneratedField::Bound => { + if end_bound__.is_some() { + return Err(serde::de::Error::duplicate_field("bound")); + } + end_bound__ = Some(window_frame::EndBound::Bound(map.next_value()?)); + } + } + } + Ok(WindowFrame { + window_frame_units: window_frame_units__.unwrap_or_default(), + start_bound: start_bound__, + end_bound: end_bound__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowFrame", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrameBound { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.window_frame_bound_type != 0 { + len += 1; + } + if self.bound_value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrameBound", len)?; + if self.window_frame_bound_type != 0 { + let v = WindowFrameBoundType::from_i32(self.window_frame_bound_type) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_bound_type)))?; + struct_ser.serialize_field("windowFrameBoundType", &v)?; + } + if let Some(v) = self.bound_value.as_ref() { + match v { + window_frame_bound::BoundValue::Value(v) => { + struct_ser.serialize_field("value", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowFrameBound { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "windowFrameBoundType", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WindowFrameBoundType, + Value, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "windowFrameBoundType" => Ok(GeneratedField::WindowFrameBoundType), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrameBound; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowFrameBound") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut window_frame_bound_type__ = None; + let mut bound_value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WindowFrameBoundType => { + if window_frame_bound_type__.is_some() { + return Err(serde::de::Error::duplicate_field("windowFrameBoundType")); + } + window_frame_bound_type__ = Some(map.next_value::()? as i32); + } + GeneratedField::Value => { + if bound_value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + bound_value__ = Some(window_frame_bound::BoundValue::Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + } + } + Ok(WindowFrameBound { + window_frame_bound_type: window_frame_bound_type__.unwrap_or_default(), + bound_value: bound_value__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowFrameBound", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrameBoundType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::CurrentRow => "CURRENT_ROW", + Self::Preceding => "PRECEDING", + Self::Following => "FOLLOWING", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for WindowFrameBoundType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "CURRENT_ROW", + "PRECEDING", + "FOLLOWING", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrameBoundType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameBoundType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameBoundType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "CURRENT_ROW" => Ok(WindowFrameBoundType::CurrentRow), + "PRECEDING" => Ok(WindowFrameBoundType::Preceding), + "FOLLOWING" => Ok(WindowFrameBoundType::Following), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrameUnits { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Rows => "ROWS", + Self::Range => "RANGE", + Self::Groups => "GROUPS", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for WindowFrameUnits { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ROWS", + "RANGE", + "GROUPS", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrameUnits; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameUnits::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameUnits::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ROWS" => Ok(WindowFrameUnits::Rows), + "RANGE" => Ok(WindowFrameUnits::Range), + "GROUPS" => Ok(WindowFrameUnits::Groups), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for WindowNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.window_expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.window_expr.is_empty() { + struct_ser.serialize_field("windowExpr", &self.window_expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "windowExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + WindowExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "windowExpr" => Ok(GeneratedField::WindowExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut window_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::WindowExpr => { + if window_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExpr")); + } + window_expr__ = Some(map.next_value()?); + } + } + } + Ok(WindowNode { + input: input__, + window_expr: window_expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.WindowNode", FIELDS, GeneratedVisitor) + } +} diff --git a/testing b/testing index e81d0c6de359..5bab2f264a23 160000 --- a/testing +++ b/testing @@ -1 +1 @@ -Subproject commit e81d0c6de35948b3be7984af8e00413b314cde6e +Subproject commit 5bab2f264a23f5af68f69ea93d24ef1e8e77fc88