This is an automated email from the ASF dual-hosted git repository. dheres pushed a commit to branch downgrade-tonic in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
commit 405211791816c2ff778064885402dfc24e48d126 Author: Andrew Lamb <[email protected]> AuthorDate: Fri Oct 25 11:40:47 2024 -0400 Revert "bump `tonic` to 0.12 and `prost` to 0.13 for `arrow-flight` (#6041)" This reverts commit 741bbf68546ffa2d9342cece82f3b1456f7a1f5b. --- arrow-flight/Cargo.toml | 11 +- arrow-flight/examples/flight_sql_server.rs | 6 +- arrow-flight/gen/Cargo.toml | 6 +- arrow-flight/gen/src/main.rs | 4 +- arrow-flight/src/arrow.flight.protocol.rs | 168 +++--- arrow-flight/src/sql/arrow.flight.protocol.sql.rs | 593 +++++++++++++--------- arrow-flight/tests/common/trailers_layer.rs | 32 +- arrow-integration-testing/Cargo.toml | 4 +- 8 files changed, 484 insertions(+), 340 deletions(-) diff --git a/arrow-flight/Cargo.toml b/arrow-flight/Cargo.toml index 702cb1360c..3270a67c7e 100644 --- a/arrow-flight/Cargo.toml +++ b/arrow-flight/Cargo.toml @@ -44,11 +44,11 @@ bytes = { version = "1", default-features = false } futures = { version = "0.3", default-features = false, features = ["alloc"] } once_cell = { version = "1", optional = true } paste = { version = "1.0" } -prost = { version = "0.13.1", default-features = false, features = ["prost-derive"] } +prost = { version = "0.12.3", default-features = false, features = ["prost-derive"] } # For Timestamp type -prost-types = { version = "0.13.1", default-features = false } +prost-types = { version = "0.12.3", default-features = false } tokio = { version = "1.0", default-features = false, features = ["macros", "rt", "rt-multi-thread"] } -tonic = { version = "0.12.3", default-features = false, features = ["transport", "codegen", "prost"] } +tonic = { version = "0.11.0", default-features = false, features = ["transport", "codegen", "prost"] } # CLI-related dependencies anyhow = { version = "1.0", optional = true } @@ -70,9 +70,8 @@ cli = ["anyhow", "arrow-array/chrono-tz", "arrow-cast/prettyprint", "clap", "tra [dev-dependencies] arrow-cast = { workspace = true, features = ["prettyprint"] } assert_cmd = "2.0.8" -http = "1.1.0" -http-body = "1.0.0" -hyper-util = "0.1" +http = "0.2.9" +http-body = "0.4.5" pin-project-lite = "0.2" tempfile = "3.3" tokio-stream = { version = "0.1", features = ["net"] } diff --git a/arrow-flight/examples/flight_sql_server.rs b/arrow-flight/examples/flight_sql_server.rs index 657298b4a8..7367886f61 100644 --- a/arrow-flight/examples/flight_sql_server.rs +++ b/arrow-flight/examples/flight_sql_server.rs @@ -792,8 +792,7 @@ impl ProstMessageExt for FetchResults { #[cfg(test)] mod tests { use super::*; - use futures::{TryFutureExt, TryStreamExt}; - use hyper_util::rt::TokioIo; + use futures::TryStreamExt; use std::fs; use std::future::Future; use std::net::SocketAddr; @@ -854,8 +853,7 @@ mod tests { .serve_with_incoming(stream); let request_future = async { - let connector = - service_fn(move |_| UnixStream::connect(path.clone()).map_ok(TokioIo::new)); + let connector = service_fn(move |_| UnixStream::connect(path.clone())); let channel = Endpoint::try_from("http://example.com";) .unwrap() .connect_with_connector(connector) diff --git a/arrow-flight/gen/Cargo.toml b/arrow-flight/gen/Cargo.toml index c7fe89beb9..7264a527ca 100644 --- a/arrow-flight/gen/Cargo.toml +++ b/arrow-flight/gen/Cargo.toml @@ -32,6 +32,6 @@ publish = false [dependencies] # Pin specific version of the tonic-build dependencies to avoid auto-generated # (and checked in) arrow.flight.protocol.rs from changing -proc-macro2 = { version = "=1.0.89", default-features = false } -prost-build = { version = "=0.13.3", default-features = false } -tonic-build = { version = "=0.12.3", default-features = false, features = ["transport", "prost"] } +proc-macro2 = { version = "=1.0.86", default-features = false } +prost-build = { version = "=0.12.6", default-features = false } +tonic-build = { version = "=0.11.0", default-features = false, features = ["transport", "prost"] } diff --git a/arrow-flight/gen/src/main.rs b/arrow-flight/gen/src/main.rs index a69134e7ac..e8019b3660 100644 --- a/arrow-flight/gen/src/main.rs +++ b/arrow-flight/gen/src/main.rs @@ -29,7 +29,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> { // protoc in Ubuntu builder needs this option .protoc_arg("--experimental_allow_proto3_optional") .out_dir("src") - .compile_protos_with_config(prost_config(), &[proto_path], &[proto_dir])?; + .compile_with_config(prost_config(), &[proto_path], &[proto_dir])?; // read file contents to string let mut file = OpenOptions::new() @@ -52,7 +52,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> { // protoc in Ubuntu builder needs this option .protoc_arg("--experimental_allow_proto3_optional") .out_dir("src/sql") - .compile_protos_with_config(prost_config(), &[proto_path], &[proto_dir])?; + .compile_with_config(prost_config(), &[proto_path], &[proto_dir])?; // read file contents to string let mut file = OpenOptions::new() diff --git a/arrow-flight/src/arrow.flight.protocol.rs b/arrow-flight/src/arrow.flight.protocol.rs index 0cd4f6948b..bc314de9d1 100644 --- a/arrow-flight/src/arrow.flight.protocol.rs +++ b/arrow-flight/src/arrow.flight.protocol.rs @@ -3,6 +3,7 @@ // This file is @generated by prost-build. /// /// The request that a client provides to a server on handshake. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct HandshakeRequest { /// @@ -14,6 +15,7 @@ pub struct HandshakeRequest { #[prost(bytes = "bytes", tag = "2")] pub payload: ::prost::bytes::Bytes, } +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct HandshakeResponse { /// @@ -27,6 +29,7 @@ pub struct HandshakeResponse { } /// /// A message for doing simple auth. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct BasicAuth { #[prost(string, tag = "2")] @@ -34,11 +37,13 @@ pub struct BasicAuth { #[prost(string, tag = "3")] pub password: ::prost::alloc::string::String, } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct Empty {} /// /// Describes an available action, including both the name used for execution /// along with a short description of the purpose of the action. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionType { #[prost(string, tag = "1")] @@ -49,6 +54,7 @@ pub struct ActionType { /// /// A service specific expression that can be used to return a limited set /// of available Arrow Flight streams. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Criteria { #[prost(bytes = "bytes", tag = "1")] @@ -56,6 +62,7 @@ pub struct Criteria { } /// /// An opaque action specific for the service. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Action { #[prost(string, tag = "1")] @@ -67,6 +74,7 @@ pub struct Action { /// The request of the CancelFlightInfo action. /// /// The request should be stored in Action.body. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelFlightInfoRequest { #[prost(message, optional, tag = "1")] @@ -76,6 +84,7 @@ pub struct CancelFlightInfoRequest { /// The request of the RenewFlightEndpoint action. /// /// The request should be stored in Action.body. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RenewFlightEndpointRequest { #[prost(message, optional, tag = "1")] @@ -83,6 +92,7 @@ pub struct RenewFlightEndpointRequest { } /// /// An opaque result returned after executing an action. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Result { #[prost(bytes = "bytes", tag = "1")] @@ -92,13 +102,15 @@ pub struct Result { /// The result of the CancelFlightInfo action. /// /// The result should be stored in Result.body. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelFlightInfoResult { #[prost(enumeration = "CancelStatus", tag = "1")] pub status: i32, } /// /// Wrap the result of a getSchema call +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct SchemaResult { /// The schema of the dataset in its IPC form: @@ -111,6 +123,7 @@ pub struct SchemaResult { /// /// The name or tag for a Flight. May be used as a way to retrieve or generate /// a flight or be used to expose a set of previously defined flights. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct FlightDescriptor { #[prost(enumeration = "flight_descriptor::DescriptorType", tag = "1")] @@ -161,9 +174,9 @@ pub mod flight_descriptor { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unknown => "UNKNOWN", - Self::Path => "PATH", - Self::Cmd => "CMD", + DescriptorType::Unknown => "UNKNOWN", + DescriptorType::Path => "PATH", + DescriptorType::Cmd => "CMD", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -180,6 +193,7 @@ pub mod flight_descriptor { /// /// The access coordinates for retrieval of a dataset. With a FlightInfo, a /// consumer is able to determine how to retrieve a dataset. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct FlightInfo { /// The schema of the dataset in its IPC form: @@ -239,6 +253,7 @@ pub struct FlightInfo { } /// /// The information to process a long-running query. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PollInfo { /// @@ -279,6 +294,7 @@ pub struct PollInfo { } /// /// A particular stream or split associated with a flight. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct FlightEndpoint { /// @@ -322,6 +338,7 @@ pub struct FlightEndpoint { /// /// A location where a Flight service will accept retrieval of a particular /// stream given a ticket. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Location { #[prost(string, tag = "1")] @@ -333,6 +350,7 @@ pub struct Location { /// /// Tickets are meant to be single use. It is an error/application-defined /// behavior to reuse a ticket. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Ticket { #[prost(bytes = "bytes", tag = "1")] @@ -340,6 +358,7 @@ pub struct Ticket { } /// /// A batch of Arrow data as part of a stream of batches. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct FlightData { /// @@ -365,6 +384,7 @@ pub struct FlightData { } /// * /// The response message associated with the submission of a DoPut. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PutResult { #[prost(bytes = "bytes", tag = "1")] @@ -398,10 +418,10 @@ impl CancelStatus { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unspecified => "CANCEL_STATUS_UNSPECIFIED", - Self::Cancelled => "CANCEL_STATUS_CANCELLED", - Self::Cancelling => "CANCEL_STATUS_CANCELLING", - Self::NotCancellable => "CANCEL_STATUS_NOT_CANCELLABLE", + CancelStatus::Unspecified => "CANCEL_STATUS_UNSPECIFIED", + CancelStatus::Cancelled => "CANCEL_STATUS_CANCELLED", + CancelStatus::Cancelling => "CANCEL_STATUS_CANCELLING", + CancelStatus::NotCancellable => "CANCEL_STATUS_NOT_CANCELLABLE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -417,13 +437,7 @@ impl CancelStatus { } /// Generated client implementations. pub mod flight_service_client { - #![allow( - unused_variables, - dead_code, - missing_docs, - clippy::wildcard_imports, - clippy::let_unit_value, - )] + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; use tonic::codegen::http::Uri; /// @@ -450,8 +464,8 @@ pub mod flight_service_client { where T: tonic::client::GrpcService<tonic::body::BoxBody>, T::Error: Into<StdError>, - T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, - <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, + T::ResponseBody: Body<Data = Bytes> + Send + 'static, + <T::ResponseBody as Body>::Error: Into<StdError> + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); @@ -476,7 +490,7 @@ pub mod flight_service_client { >, <T as tonic::codegen::Service< http::Request<tonic::body::BoxBody>, - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, + >>::Error: Into<StdError> + Send + Sync, { FlightServiceClient::new(InterceptedService::new(inner, interceptor)) } @@ -527,7 +541,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -560,7 +575,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -594,7 +610,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -643,7 +660,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -674,7 +692,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -705,7 +724,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -736,7 +756,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -766,7 +787,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -799,7 +821,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -829,7 +852,8 @@ pub mod flight_service_client { .ready() .await .map_err(|e| { - tonic::Status::unknown( + tonic::Status::new( + tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; @@ -848,22 +872,16 @@ pub mod flight_service_client { } /// Generated server implementations. pub mod flight_service_server { - #![allow( - unused_variables, - dead_code, - missing_docs, - clippy::wildcard_imports, - clippy::let_unit_value, - )] + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; /// Generated trait containing gRPC methods that should be implemented for use with FlightServiceServer. #[async_trait] - pub trait FlightService: std::marker::Send + std::marker::Sync + 'static { + pub trait FlightService: Send + Sync + 'static { /// Server streaming response type for the Handshake method. type HandshakeStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::HandshakeResponse, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// Handshake between client and server. Depending on the server, the @@ -878,7 +896,7 @@ pub mod flight_service_server { type ListFlightsStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::FlightInfo, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// Get a list of available streams given a particular criteria. Most flight @@ -949,7 +967,7 @@ pub mod flight_service_server { type DoGetStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::FlightData, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// Retrieve a single stream associated with a particular descriptor @@ -964,7 +982,7 @@ pub mod flight_service_server { type DoPutStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::PutResult, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// Push a stream to the flight service associated with a particular @@ -981,7 +999,7 @@ pub mod flight_service_server { type DoExchangeStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::FlightData, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// Open a bidirectional data channel for a given descriptor. This @@ -997,7 +1015,7 @@ pub mod flight_service_server { type DoActionStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::Result, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// Flight services can support an arbitrary number of simple actions in @@ -1014,7 +1032,7 @@ pub mod flight_service_server { type ListActionsStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result<super::ActionType, tonic::Status>, > - + std::marker::Send + + Send + 'static; /// /// A flight service exposes all of the available action types that it has @@ -1034,18 +1052,20 @@ pub mod flight_service_server { /// accessed using the Arrow Flight Protocol. Additionally, a flight service /// can expose a set of actions that are available. #[derive(Debug)] - pub struct FlightServiceServer<T> { - inner: Arc<T>, + pub struct FlightServiceServer<T: FlightService> { + inner: _Inner<T>, accept_compression_encodings: EnabledCompressionEncodings, send_compression_encodings: EnabledCompressionEncodings, max_decoding_message_size: Option<usize>, max_encoding_message_size: Option<usize>, } - impl<T> FlightServiceServer<T> { + struct _Inner<T>(Arc<T>); + impl<T: FlightService> FlightServiceServer<T> { pub fn new(inner: T) -> Self { Self::from_arc(Arc::new(inner)) } pub fn from_arc(inner: Arc<T>) -> Self { + let inner = _Inner(inner); Self { inner, accept_compression_encodings: Default::default(), @@ -1095,8 +1115,8 @@ pub mod flight_service_server { impl<T, B> tonic::codegen::Service<http::Request<B>> for FlightServiceServer<T> where T: FlightService, - B: Body + std::marker::Send + 'static, - B::Error: Into<StdError> + std::marker::Send + 'static, + B: Body + Send + 'static, + B::Error: Into<StdError> + Send + 'static, { type Response = http::Response<tonic::body::BoxBody>; type Error = std::convert::Infallible; @@ -1108,6 +1128,7 @@ pub mod flight_service_server { Poll::Ready(Ok(())) } fn call(&mut self, req: http::Request<B>) -> Self::Future { + let inner = self.inner.clone(); match req.uri().path() { "/arrow.flight.protocol.FlightService/Handshake" => { #[allow(non_camel_case_types)] @@ -1141,6 +1162,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = HandshakeSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1187,6 +1209,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = ListFlightsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1232,6 +1255,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = GetFlightInfoSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1278,6 +1302,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = PollFlightInfoSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1323,6 +1348,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = GetSchemaSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1369,6 +1395,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = DoGetSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1415,6 +1442,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = DoPutSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1461,6 +1489,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = DoExchangeSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1507,6 +1536,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = DoActionSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1553,6 +1583,7 @@ pub mod flight_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { + let inner = inner.0; let method = ListActionsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -1571,25 +1602,20 @@ pub mod flight_service_server { } _ => { Box::pin(async move { - let mut response = http::Response::new(empty_body()); - let headers = response.headers_mut(); - headers - .insert( - tonic::Status::GRPC_STATUS, - (tonic::Code::Unimplemented as i32).into(), - ); - headers - .insert( - http::header::CONTENT_TYPE, - tonic::metadata::GRPC_CONTENT_TYPE, - ); - Ok(response) + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) }) } } } } - impl<T> Clone for FlightServiceServer<T> { + impl<T: FlightService> Clone for FlightServiceServer<T> { fn clone(&self) -> Self { let inner = self.inner.clone(); Self { @@ -1601,9 +1627,17 @@ pub mod flight_service_server { } } } - /// Generated gRPC service name - pub const SERVICE_NAME: &str = "arrow.flight.protocol.FlightService"; - impl<T> tonic::server::NamedService for FlightServiceServer<T> { - const NAME: &'static str = SERVICE_NAME; + impl<T: FlightService> Clone for _Inner<T> { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl<T: FlightService> tonic::server::NamedService for FlightServiceServer<T> { + const NAME: &'static str = "arrow.flight.protocol.FlightService"; } } diff --git a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs index 7a37a0b288..822f095ed0 100644 --- a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs +++ b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs @@ -19,6 +19,7 @@ /// int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>> /// > /// where there is one row per requested piece of metadata information. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetSqlInfo { /// @@ -99,7 +100,8 @@ pub struct CommandGetSqlInfo { /// is only relevant to be used by ODBC). /// > /// The returned data should be ordered by data_type and then by type_name. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetXdbcTypeInfo { /// /// Specifies the data type to search for the info. @@ -118,7 +120,8 @@ pub struct CommandGetXdbcTypeInfo { /// catalog_name: utf8 not null /// > /// The returned data should be ordered by catalog_name. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetCatalogs {} /// /// Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend. @@ -133,6 +136,7 @@ pub struct CommandGetCatalogs {} /// db_schema_name: utf8 not null /// > /// The returned data should be ordered by catalog_name, then db_schema_name. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetDbSchemas { /// @@ -177,6 +181,7 @@ pub struct CommandGetDbSchemas { /// - ARROW:FLIGHT:SQL:IS_READ_ONLY - "1" indicates if the column is read only, "0" otherwise. /// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise. /// The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetTables { /// @@ -226,7 +231,8 @@ pub struct CommandGetTables { /// table_type: utf8 not null /// > /// The returned data should be ordered by table_type. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetTableTypes {} /// /// Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend. @@ -244,6 +250,7 @@ pub struct CommandGetTableTypes {} /// key_sequence: int32 not null /// > /// The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetPrimaryKeys { /// @@ -287,6 +294,7 @@ pub struct CommandGetPrimaryKeys { /// > /// The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence. /// update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetExportedKeys { /// @@ -334,6 +342,7 @@ pub struct CommandGetExportedKeys { /// - 2 = SET NULL /// - 3 = NO ACTION /// - 4 = SET DEFAULT +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetImportedKeys { /// @@ -383,6 +392,7 @@ pub struct CommandGetImportedKeys { /// - 2 = SET NULL /// - 3 = NO ACTION /// - 4 = SET DEFAULT +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandGetCrossReference { /// * @@ -420,6 +430,7 @@ pub struct CommandGetCrossReference { } /// /// Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionCreatePreparedStatementRequest { /// The valid SQL string to create a prepared statement for. @@ -432,6 +443,7 @@ pub struct ActionCreatePreparedStatementRequest { } /// /// An embedded message describing a Substrait plan to execute. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct SubstraitPlan { /// The serialized substrait.Plan to create a prepared statement for. @@ -448,6 +460,7 @@ pub struct SubstraitPlan { } /// /// Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionCreatePreparedSubstraitPlanRequest { /// The serialized substrait.Plan to create a prepared statement for. @@ -466,6 +479,7 @@ pub struct ActionCreatePreparedSubstraitPlanRequest { /// - Automatically, by a server timeout. /// /// The result should be wrapped in a google.protobuf.Any message. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionCreatePreparedStatementResult { /// Opaque handle for the prepared statement on the server. @@ -486,6 +500,7 @@ pub struct ActionCreatePreparedStatementResult { /// /// Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend. /// Closes server resources associated with the prepared statement handle. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionClosePreparedStatementRequest { /// Opaque handle for the prepared statement on the server. @@ -495,7 +510,8 @@ pub struct ActionClosePreparedStatementRequest { /// /// Request message for the "BeginTransaction" action. /// Begins a transaction. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionBeginTransactionRequest {} /// /// Request message for the "BeginSavepoint" action. @@ -503,6 +519,7 @@ pub struct ActionBeginTransactionRequest {} /// /// Only supported if FLIGHT_SQL_TRANSACTION is /// FLIGHT_SQL_TRANSACTION_SUPPORT_SAVEPOINT. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionBeginSavepointRequest { /// The transaction to which a savepoint belongs. @@ -520,6 +537,7 @@ pub struct ActionBeginSavepointRequest { /// automatically rolled back. /// /// The result should be wrapped in a google.protobuf.Any message. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionBeginTransactionResult { /// Opaque handle for the transaction on the server. @@ -534,6 +552,7 @@ pub struct ActionBeginTransactionResult { /// out, then the savepoint is also invalidated. /// /// The result should be wrapped in a google.protobuf.Any message. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionBeginSavepointResult { /// Opaque handle for the savepoint on the server. @@ -547,6 +566,7 @@ pub struct ActionBeginSavepointResult { /// /// If the action completes successfully, the transaction handle is /// invalidated, as are all associated savepoints. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionEndTransactionRequest { /// Opaque handle for the transaction on the server. @@ -584,9 +604,9 @@ pub mod action_end_transaction_request { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unspecified => "END_TRANSACTION_UNSPECIFIED", - Self::Commit => "END_TRANSACTION_COMMIT", - Self::Rollback => "END_TRANSACTION_ROLLBACK", + EndTransaction::Unspecified => "END_TRANSACTION_UNSPECIFIED", + EndTransaction::Commit => "END_TRANSACTION_COMMIT", + EndTransaction::Rollback => "END_TRANSACTION_ROLLBACK", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -609,6 +629,7 @@ pub mod action_end_transaction_request { /// Releasing a savepoint invalidates that savepoint. Rolling back to /// a savepoint does not invalidate the savepoint, but invalidates all /// savepoints created after the current savepoint. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionEndSavepointRequest { /// Opaque handle for the savepoint on the server. @@ -646,9 +667,9 @@ pub mod action_end_savepoint_request { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unspecified => "END_SAVEPOINT_UNSPECIFIED", - Self::Release => "END_SAVEPOINT_RELEASE", - Self::Rollback => "END_SAVEPOINT_ROLLBACK", + EndSavepoint::Unspecified => "END_SAVEPOINT_UNSPECIFIED", + EndSavepoint::Release => "END_SAVEPOINT_RELEASE", + EndSavepoint::Rollback => "END_SAVEPOINT_ROLLBACK", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -678,6 +699,7 @@ pub mod action_end_savepoint_request { /// - ARROW:FLIGHT:SQL:IS_READ_ONLY - "1" indicates if the column is read only, "0" otherwise. /// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise. /// - GetFlightInfo: execute the query. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandStatementQuery { /// The SQL syntax. @@ -704,6 +726,7 @@ pub struct CommandStatementQuery { /// - ARROW:FLIGHT:SQL:IS_SEARCHABLE - "1" indicates if the column is searchable via WHERE clause, "0" otherwise. /// - GetFlightInfo: execute the query. /// - DoPut: execute the query. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandStatementSubstraitPlan { /// A serialized substrait.Plan @@ -716,6 +739,7 @@ pub struct CommandStatementSubstraitPlan { /// * /// Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery. /// This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct TicketStatementQuery { /// Unique identifier for the instance of the statement to execute. @@ -742,6 +766,7 @@ pub struct TicketStatementQuery { /// for the parameters when determining the schema. /// - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution. /// - GetFlightInfo: execute the prepared statement instance. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandPreparedStatementQuery { /// Opaque handle for the prepared statement on the server. @@ -751,6 +776,7 @@ pub struct CommandPreparedStatementQuery { /// /// Represents a SQL update query. Used in the command member of FlightDescriptor /// for the RPC call DoPut to cause the server to execute the included SQL update. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandStatementUpdate { /// The SQL syntax. @@ -764,6 +790,7 @@ pub struct CommandStatementUpdate { /// Represents a SQL update query. Used in the command member of FlightDescriptor /// for the RPC call DoPut to cause the server to execute the included /// prepared statement handle as an update. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandPreparedStatementUpdate { /// Opaque handle for the prepared statement on the server. @@ -774,6 +801,7 @@ pub struct CommandPreparedStatementUpdate { /// Represents a bulk ingestion request. Used in the command member of FlightDescriptor /// for the the RPC call DoPut to cause the server load the contents of the stream's /// FlightData into the target destination. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommandStatementIngest { /// The behavior for handling the table definition. @@ -810,7 +838,8 @@ pub struct CommandStatementIngest { /// Nested message and enum types in `CommandStatementIngest`. pub mod command_statement_ingest { /// Options for table definition behavior - #[derive(Clone, Copy, PartialEq, ::prost::Message)] + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] pub struct TableDefinitionOptions { #[prost( enumeration = "table_definition_options::TableNotExistOption", @@ -850,9 +879,11 @@ pub mod command_statement_ingest { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unspecified => "TABLE_NOT_EXIST_OPTION_UNSPECIFIED", - Self::Create => "TABLE_NOT_EXIST_OPTION_CREATE", - Self::Fail => "TABLE_NOT_EXIST_OPTION_FAIL", + TableNotExistOption::Unspecified => { + "TABLE_NOT_EXIST_OPTION_UNSPECIFIED" + } + TableNotExistOption::Create => "TABLE_NOT_EXIST_OPTION_CREATE", + TableNotExistOption::Fail => "TABLE_NOT_EXIST_OPTION_FAIL", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -895,10 +926,10 @@ pub mod command_statement_ingest { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unspecified => "TABLE_EXISTS_OPTION_UNSPECIFIED", - Self::Fail => "TABLE_EXISTS_OPTION_FAIL", - Self::Append => "TABLE_EXISTS_OPTION_APPEND", - Self::Replace => "TABLE_EXISTS_OPTION_REPLACE", + TableExistsOption::Unspecified => "TABLE_EXISTS_OPTION_UNSPECIFIED", + TableExistsOption::Fail => "TABLE_EXISTS_OPTION_FAIL", + TableExistsOption::Append => "TABLE_EXISTS_OPTION_APPEND", + TableExistsOption::Replace => "TABLE_EXISTS_OPTION_REPLACE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -918,7 +949,8 @@ pub mod command_statement_ingest { /// Returned from the RPC call DoPut when a CommandStatementUpdate, /// CommandPreparedStatementUpdate, or CommandStatementIngest was /// in the request, containing results from the update. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct DoPutUpdateResult { /// The number of records updated. A return value of -1 represents /// an unknown updated record count. @@ -930,6 +962,7 @@ pub struct DoPutUpdateResult { /// *Note on legacy behavior*: previous versions of the protocol did not return any result for /// this command, and that behavior should still be supported by clients. In that case, the client /// can continue as though the fields in this message were not provided or set to sensible default values. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DoPutPreparedStatementResult { /// Represents a (potentially updated) opaque handle for the prepared statement on the server. @@ -959,6 +992,7 @@ pub struct DoPutPreparedStatementResult { /// /// This command is deprecated since 13.0.0. Use the "CancelFlightInfo" /// action with DoAction instead. +#[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionCancelQueryRequest { /// The result of the GetFlightInfo RPC that initiated the query. @@ -975,7 +1009,8 @@ pub struct ActionCancelQueryRequest { /// /// This command is deprecated since 13.0.0. Use the "CancelFlightInfo" /// action with DoAction instead. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionCancelQueryResult { #[prost(enumeration = "action_cancel_query_result::CancelResult", tag = "1")] pub result: i32, @@ -1016,10 +1051,10 @@ pub mod action_cancel_query_result { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unspecified => "CANCEL_RESULT_UNSPECIFIED", - Self::Cancelled => "CANCEL_RESULT_CANCELLED", - Self::Cancelling => "CANCEL_RESULT_CANCELLING", - Self::NotCancellable => "CANCEL_RESULT_NOT_CANCELLABLE", + CancelResult::Unspecified => "CANCEL_RESULT_UNSPECIFIED", + CancelResult::Cancelled => "CANCEL_RESULT_CANCELLED", + CancelResult::Cancelling => "CANCEL_RESULT_CANCELLING", + CancelResult::NotCancellable => "CANCEL_RESULT_NOT_CANCELLABLE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -1654,131 +1689,135 @@ impl SqlInfo { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::FlightSqlServerName => "FLIGHT_SQL_SERVER_NAME", - Self::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION", - Self::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION", - Self::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY", - Self::FlightSqlServerSql => "FLIGHT_SQL_SERVER_SQL", - Self::FlightSqlServerSubstrait => "FLIGHT_SQL_SERVER_SUBSTRAIT", - Self::FlightSqlServerSubstraitMinVersion => { + SqlInfo::FlightSqlServerName => "FLIGHT_SQL_SERVER_NAME", + SqlInfo::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION", + SqlInfo::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION", + SqlInfo::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY", + SqlInfo::FlightSqlServerSql => "FLIGHT_SQL_SERVER_SQL", + SqlInfo::FlightSqlServerSubstrait => "FLIGHT_SQL_SERVER_SUBSTRAIT", + SqlInfo::FlightSqlServerSubstraitMinVersion => { "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION" } - Self::FlightSqlServerSubstraitMaxVersion => { + SqlInfo::FlightSqlServerSubstraitMaxVersion => { "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION" } - Self::FlightSqlServerTransaction => "FLIGHT_SQL_SERVER_TRANSACTION", - Self::FlightSqlServerCancel => "FLIGHT_SQL_SERVER_CANCEL", - Self::FlightSqlServerBulkIngestion => "FLIGHT_SQL_SERVER_BULK_INGESTION", - Self::FlightSqlServerIngestTransactionsSupported => { + SqlInfo::FlightSqlServerTransaction => "FLIGHT_SQL_SERVER_TRANSACTION", + SqlInfo::FlightSqlServerCancel => "FLIGHT_SQL_SERVER_CANCEL", + SqlInfo::FlightSqlServerBulkIngestion => "FLIGHT_SQL_SERVER_BULK_INGESTION", + SqlInfo::FlightSqlServerIngestTransactionsSupported => { "FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED" } - Self::FlightSqlServerStatementTimeout => { + SqlInfo::FlightSqlServerStatementTimeout => { "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT" } - Self::FlightSqlServerTransactionTimeout => { + SqlInfo::FlightSqlServerTransactionTimeout => { "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT" } - Self::SqlDdlCatalog => "SQL_DDL_CATALOG", - Self::SqlDdlSchema => "SQL_DDL_SCHEMA", - Self::SqlDdlTable => "SQL_DDL_TABLE", - Self::SqlIdentifierCase => "SQL_IDENTIFIER_CASE", - Self::SqlIdentifierQuoteChar => "SQL_IDENTIFIER_QUOTE_CHAR", - Self::SqlQuotedIdentifierCase => "SQL_QUOTED_IDENTIFIER_CASE", - Self::SqlAllTablesAreSelectable => "SQL_ALL_TABLES_ARE_SELECTABLE", - Self::SqlNullOrdering => "SQL_NULL_ORDERING", - Self::SqlKeywords => "SQL_KEYWORDS", - Self::SqlNumericFunctions => "SQL_NUMERIC_FUNCTIONS", - Self::SqlStringFunctions => "SQL_STRING_FUNCTIONS", - Self::SqlSystemFunctions => "SQL_SYSTEM_FUNCTIONS", - Self::SqlDatetimeFunctions => "SQL_DATETIME_FUNCTIONS", - Self::SqlSearchStringEscape => "SQL_SEARCH_STRING_ESCAPE", - Self::SqlExtraNameCharacters => "SQL_EXTRA_NAME_CHARACTERS", - Self::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING", - Self::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL", - Self::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT", - Self::SqlSupportsTableCorrelationNames => { + SqlInfo::SqlDdlCatalog => "SQL_DDL_CATALOG", + SqlInfo::SqlDdlSchema => "SQL_DDL_SCHEMA", + SqlInfo::SqlDdlTable => "SQL_DDL_TABLE", + SqlInfo::SqlIdentifierCase => "SQL_IDENTIFIER_CASE", + SqlInfo::SqlIdentifierQuoteChar => "SQL_IDENTIFIER_QUOTE_CHAR", + SqlInfo::SqlQuotedIdentifierCase => "SQL_QUOTED_IDENTIFIER_CASE", + SqlInfo::SqlAllTablesAreSelectable => "SQL_ALL_TABLES_ARE_SELECTABLE", + SqlInfo::SqlNullOrdering => "SQL_NULL_ORDERING", + SqlInfo::SqlKeywords => "SQL_KEYWORDS", + SqlInfo::SqlNumericFunctions => "SQL_NUMERIC_FUNCTIONS", + SqlInfo::SqlStringFunctions => "SQL_STRING_FUNCTIONS", + SqlInfo::SqlSystemFunctions => "SQL_SYSTEM_FUNCTIONS", + SqlInfo::SqlDatetimeFunctions => "SQL_DATETIME_FUNCTIONS", + SqlInfo::SqlSearchStringEscape => "SQL_SEARCH_STRING_ESCAPE", + SqlInfo::SqlExtraNameCharacters => "SQL_EXTRA_NAME_CHARACTERS", + SqlInfo::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING", + SqlInfo::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL", + SqlInfo::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT", + SqlInfo::SqlSupportsTableCorrelationNames => { "SQL_SUPPORTS_TABLE_CORRELATION_NAMES" } - Self::SqlSupportsDifferentTableCorrelationNames => { + SqlInfo::SqlSupportsDifferentTableCorrelationNames => { "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES" } - Self::SqlSupportsExpressionsInOrderBy => { + SqlInfo::SqlSupportsExpressionsInOrderBy => { "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY" } - Self::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED", - Self::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY", - Self::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE", - Self::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS", - Self::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR", - Self::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL", - Self::SqlSupportsIntegrityEnhancementFacility => { + SqlInfo::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED", + SqlInfo::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY", + SqlInfo::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE", + SqlInfo::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS", + SqlInfo::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR", + SqlInfo::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL", + SqlInfo::SqlSupportsIntegrityEnhancementFacility => { "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY" } - Self::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL", - Self::SqlSchemaTerm => "SQL_SCHEMA_TERM", - Self::SqlProcedureTerm => "SQL_PROCEDURE_TERM", - Self::SqlCatalogTerm => "SQL_CATALOG_TERM", - Self::SqlCatalogAtStart => "SQL_CATALOG_AT_START", - Self::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS", - Self::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS", - Self::SqlSupportedPositionedCommands => "SQL_SUPPORTED_POSITIONED_COMMANDS", - Self::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED", - Self::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED", - Self::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES", - Self::SqlCorrelatedSubqueriesSupported => { + SqlInfo::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL", + SqlInfo::SqlSchemaTerm => "SQL_SCHEMA_TERM", + SqlInfo::SqlProcedureTerm => "SQL_PROCEDURE_TERM", + SqlInfo::SqlCatalogTerm => "SQL_CATALOG_TERM", + SqlInfo::SqlCatalogAtStart => "SQL_CATALOG_AT_START", + SqlInfo::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS", + SqlInfo::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS", + SqlInfo::SqlSupportedPositionedCommands => { + "SQL_SUPPORTED_POSITIONED_COMMANDS" + } + SqlInfo::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED", + SqlInfo::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED", + SqlInfo::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES", + SqlInfo::SqlCorrelatedSubqueriesSupported => { "SQL_CORRELATED_SUBQUERIES_SUPPORTED" } - Self::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS", - Self::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH", - Self::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH", - Self::SqlMaxColumnNameLength => "SQL_MAX_COLUMN_NAME_LENGTH", - Self::SqlMaxColumnsInGroupBy => "SQL_MAX_COLUMNS_IN_GROUP_BY", - Self::SqlMaxColumnsInIndex => "SQL_MAX_COLUMNS_IN_INDEX", - Self::SqlMaxColumnsInOrderBy => "SQL_MAX_COLUMNS_IN_ORDER_BY", - Self::SqlMaxColumnsInSelect => "SQL_MAX_COLUMNS_IN_SELECT", - Self::SqlMaxColumnsInTable => "SQL_MAX_COLUMNS_IN_TABLE", - Self::SqlMaxConnections => "SQL_MAX_CONNECTIONS", - Self::SqlMaxCursorNameLength => "SQL_MAX_CURSOR_NAME_LENGTH", - Self::SqlMaxIndexLength => "SQL_MAX_INDEX_LENGTH", - Self::SqlDbSchemaNameLength => "SQL_DB_SCHEMA_NAME_LENGTH", - Self::SqlMaxProcedureNameLength => "SQL_MAX_PROCEDURE_NAME_LENGTH", - Self::SqlMaxCatalogNameLength => "SQL_MAX_CATALOG_NAME_LENGTH", - Self::SqlMaxRowSize => "SQL_MAX_ROW_SIZE", - Self::SqlMaxRowSizeIncludesBlobs => "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS", - Self::SqlMaxStatementLength => "SQL_MAX_STATEMENT_LENGTH", - Self::SqlMaxStatements => "SQL_MAX_STATEMENTS", - Self::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH", - Self::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT", - Self::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH", - Self::SqlDefaultTransactionIsolation => "SQL_DEFAULT_TRANSACTION_ISOLATION", - Self::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED", - Self::SqlSupportedTransactionsIsolationLevels => { + SqlInfo::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS", + SqlInfo::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH", + SqlInfo::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH", + SqlInfo::SqlMaxColumnNameLength => "SQL_MAX_COLUMN_NAME_LENGTH", + SqlInfo::SqlMaxColumnsInGroupBy => "SQL_MAX_COLUMNS_IN_GROUP_BY", + SqlInfo::SqlMaxColumnsInIndex => "SQL_MAX_COLUMNS_IN_INDEX", + SqlInfo::SqlMaxColumnsInOrderBy => "SQL_MAX_COLUMNS_IN_ORDER_BY", + SqlInfo::SqlMaxColumnsInSelect => "SQL_MAX_COLUMNS_IN_SELECT", + SqlInfo::SqlMaxColumnsInTable => "SQL_MAX_COLUMNS_IN_TABLE", + SqlInfo::SqlMaxConnections => "SQL_MAX_CONNECTIONS", + SqlInfo::SqlMaxCursorNameLength => "SQL_MAX_CURSOR_NAME_LENGTH", + SqlInfo::SqlMaxIndexLength => "SQL_MAX_INDEX_LENGTH", + SqlInfo::SqlDbSchemaNameLength => "SQL_DB_SCHEMA_NAME_LENGTH", + SqlInfo::SqlMaxProcedureNameLength => "SQL_MAX_PROCEDURE_NAME_LENGTH", + SqlInfo::SqlMaxCatalogNameLength => "SQL_MAX_CATALOG_NAME_LENGTH", + SqlInfo::SqlMaxRowSize => "SQL_MAX_ROW_SIZE", + SqlInfo::SqlMaxRowSizeIncludesBlobs => "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS", + SqlInfo::SqlMaxStatementLength => "SQL_MAX_STATEMENT_LENGTH", + SqlInfo::SqlMaxStatements => "SQL_MAX_STATEMENTS", + SqlInfo::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH", + SqlInfo::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT", + SqlInfo::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH", + SqlInfo::SqlDefaultTransactionIsolation => { + "SQL_DEFAULT_TRANSACTION_ISOLATION" + } + SqlInfo::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED", + SqlInfo::SqlSupportedTransactionsIsolationLevels => { "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS" } - Self::SqlDataDefinitionCausesTransactionCommit => { + SqlInfo::SqlDataDefinitionCausesTransactionCommit => { "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT" } - Self::SqlDataDefinitionsInTransactionsIgnored => { + SqlInfo::SqlDataDefinitionsInTransactionsIgnored => { "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED" } - Self::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES", - Self::SqlSupportedConcurrenciesForResultSetUnspecified => { + SqlInfo::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES", + SqlInfo::SqlSupportedConcurrenciesForResultSetUnspecified => { "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED" } - Self::SqlSupportedConcurrenciesForResultSetForwardOnly => { + SqlInfo::SqlSupportedConcurrenciesForResultSetForwardOnly => { "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY" } - Self::SqlSupportedConcurrenciesForResultSetScrollSensitive => { + SqlInfo::SqlSupportedConcurrenciesForResultSetScrollSensitive => { "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE" } - Self::SqlSupportedConcurrenciesForResultSetScrollInsensitive => { + SqlInfo::SqlSupportedConcurrenciesForResultSetScrollInsensitive => { "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE" } - Self::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED", - Self::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED", - Self::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED", - Self::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY", - Self::SqlStoredFunctionsUsingCallSyntaxSupported => { + SqlInfo::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED", + SqlInfo::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED", + SqlInfo::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED", + SqlInfo::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY", + SqlInfo::SqlStoredFunctionsUsingCallSyntaxSupported => { "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED" } } @@ -1945,9 +1984,11 @@ impl SqlSupportedTransaction { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::None => "SQL_SUPPORTED_TRANSACTION_NONE", - Self::Transaction => "SQL_SUPPORTED_TRANSACTION_TRANSACTION", - Self::Savepoint => "SQL_SUPPORTED_TRANSACTION_SAVEPOINT", + SqlSupportedTransaction::None => "SQL_SUPPORTED_TRANSACTION_NONE", + SqlSupportedTransaction::Transaction => { + "SQL_SUPPORTED_TRANSACTION_TRANSACTION" + } + SqlSupportedTransaction::Savepoint => "SQL_SUPPORTED_TRANSACTION_SAVEPOINT", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -1975,12 +2016,18 @@ impl SqlSupportedCaseSensitivity { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlCaseSensitivityUnknown => "SQL_CASE_SENSITIVITY_UNKNOWN", - Self::SqlCaseSensitivityCaseInsensitive => { + SqlSupportedCaseSensitivity::SqlCaseSensitivityUnknown => { + "SQL_CASE_SENSITIVITY_UNKNOWN" + } + SqlSupportedCaseSensitivity::SqlCaseSensitivityCaseInsensitive => { "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE" } - Self::SqlCaseSensitivityUppercase => "SQL_CASE_SENSITIVITY_UPPERCASE", - Self::SqlCaseSensitivityLowercase => "SQL_CASE_SENSITIVITY_LOWERCASE", + SqlSupportedCaseSensitivity::SqlCaseSensitivityUppercase => { + "SQL_CASE_SENSITIVITY_UPPERCASE" + } + SqlSupportedCaseSensitivity::SqlCaseSensitivityLowercase => { + "SQL_CASE_SENSITIVITY_LOWERCASE" + } } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2011,10 +2058,10 @@ impl SqlNullOrdering { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlNullsSortedHigh => "SQL_NULLS_SORTED_HIGH", - Self::SqlNullsSortedLow => "SQL_NULLS_SORTED_LOW", - Self::SqlNullsSortedAtStart => "SQL_NULLS_SORTED_AT_START", - Self::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END", + SqlNullOrdering::SqlNullsSortedHigh => "SQL_NULLS_SORTED_HIGH", + SqlNullOrdering::SqlNullsSortedLow => "SQL_NULLS_SORTED_LOW", + SqlNullOrdering::SqlNullsSortedAtStart => "SQL_NULLS_SORTED_AT_START", + SqlNullOrdering::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2042,9 +2089,9 @@ impl SupportedSqlGrammar { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlMinimumGrammar => "SQL_MINIMUM_GRAMMAR", - Self::SqlCoreGrammar => "SQL_CORE_GRAMMAR", - Self::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR", + SupportedSqlGrammar::SqlMinimumGrammar => "SQL_MINIMUM_GRAMMAR", + SupportedSqlGrammar::SqlCoreGrammar => "SQL_CORE_GRAMMAR", + SupportedSqlGrammar::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2071,9 +2118,11 @@ impl SupportedAnsi92SqlGrammarLevel { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Ansi92EntrySql => "ANSI92_ENTRY_SQL", - Self::Ansi92IntermediateSql => "ANSI92_INTERMEDIATE_SQL", - Self::Ansi92FullSql => "ANSI92_FULL_SQL", + SupportedAnsi92SqlGrammarLevel::Ansi92EntrySql => "ANSI92_ENTRY_SQL", + SupportedAnsi92SqlGrammarLevel::Ansi92IntermediateSql => { + "ANSI92_INTERMEDIATE_SQL" + } + SupportedAnsi92SqlGrammarLevel::Ansi92FullSql => "ANSI92_FULL_SQL", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2100,9 +2149,9 @@ impl SqlOuterJoinsSupportLevel { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlJoinsUnsupported => "SQL_JOINS_UNSUPPORTED", - Self::SqlLimitedOuterJoins => "SQL_LIMITED_OUTER_JOINS", - Self::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS", + SqlOuterJoinsSupportLevel::SqlJoinsUnsupported => "SQL_JOINS_UNSUPPORTED", + SqlOuterJoinsSupportLevel::SqlLimitedOuterJoins => "SQL_LIMITED_OUTER_JOINS", + SqlOuterJoinsSupportLevel::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2128,8 +2177,8 @@ impl SqlSupportedGroupBy { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlGroupByUnrelated => "SQL_GROUP_BY_UNRELATED", - Self::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT", + SqlSupportedGroupBy::SqlGroupByUnrelated => "SQL_GROUP_BY_UNRELATED", + SqlSupportedGroupBy::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2155,9 +2204,13 @@ impl SqlSupportedElementActions { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlElementInProcedureCalls => "SQL_ELEMENT_IN_PROCEDURE_CALLS", - Self::SqlElementInIndexDefinitions => "SQL_ELEMENT_IN_INDEX_DEFINITIONS", - Self::SqlElementInPrivilegeDefinitions => { + SqlSupportedElementActions::SqlElementInProcedureCalls => { + "SQL_ELEMENT_IN_PROCEDURE_CALLS" + } + SqlSupportedElementActions::SqlElementInIndexDefinitions => { + "SQL_ELEMENT_IN_INDEX_DEFINITIONS" + } + SqlSupportedElementActions::SqlElementInPrivilegeDefinitions => { "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS" } } @@ -2189,8 +2242,12 @@ impl SqlSupportedPositionedCommands { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlPositionedDelete => "SQL_POSITIONED_DELETE", - Self::SqlPositionedUpdate => "SQL_POSITIONED_UPDATE", + SqlSupportedPositionedCommands::SqlPositionedDelete => { + "SQL_POSITIONED_DELETE" + } + SqlSupportedPositionedCommands::SqlPositionedUpdate => { + "SQL_POSITIONED_UPDATE" + } } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2217,10 +2274,14 @@ impl SqlSupportedSubqueries { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlSubqueriesInComparisons => "SQL_SUBQUERIES_IN_COMPARISONS", - Self::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS", - Self::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS", - Self::SqlSubqueriesInQuantifieds => "SQL_SUBQUERIES_IN_QUANTIFIEDS", + SqlSupportedSubqueries::SqlSubqueriesInComparisons => { + "SQL_SUBQUERIES_IN_COMPARISONS" + } + SqlSupportedSubqueries::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS", + SqlSupportedSubqueries::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS", + SqlSupportedSubqueries::SqlSubqueriesInQuantifieds => { + "SQL_SUBQUERIES_IN_QUANTIFIEDS" + } } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2247,8 +2308,8 @@ impl SqlSupportedUnions { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlUnion => "SQL_UNION", - Self::SqlUnionAll => "SQL_UNION_ALL", + SqlSupportedUnions::SqlUnion => "SQL_UNION", + SqlSupportedUnions::SqlUnionAll => "SQL_UNION_ALL", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2276,11 +2337,19 @@ impl SqlTransactionIsolationLevel { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlTransactionNone => "SQL_TRANSACTION_NONE", - Self::SqlTransactionReadUncommitted => "SQL_TRANSACTION_READ_UNCOMMITTED", - Self::SqlTransactionReadCommitted => "SQL_TRANSACTION_READ_COMMITTED", - Self::SqlTransactionRepeatableRead => "SQL_TRANSACTION_REPEATABLE_READ", - Self::SqlTransactionSerializable => "SQL_TRANSACTION_SERIALIZABLE", + SqlTransactionIsolationLevel::SqlTransactionNone => "SQL_TRANSACTION_NONE", + SqlTransactionIsolationLevel::SqlTransactionReadUncommitted => { + "SQL_TRANSACTION_READ_UNCOMMITTED" + } + SqlTransactionIsolationLevel::SqlTransactionReadCommitted => { + "SQL_TRANSACTION_READ_COMMITTED" + } + SqlTransactionIsolationLevel::SqlTransactionRepeatableRead => { + "SQL_TRANSACTION_REPEATABLE_READ" + } + SqlTransactionIsolationLevel::SqlTransactionSerializable => { + "SQL_TRANSACTION_SERIALIZABLE" + } } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2311,9 +2380,15 @@ impl SqlSupportedTransactions { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlTransactionUnspecified => "SQL_TRANSACTION_UNSPECIFIED", - Self::SqlDataDefinitionTransactions => "SQL_DATA_DEFINITION_TRANSACTIONS", - Self::SqlDataManipulationTransactions => "SQL_DATA_MANIPULATION_TRANSACTIONS", + SqlSupportedTransactions::SqlTransactionUnspecified => { + "SQL_TRANSACTION_UNSPECIFIED" + } + SqlSupportedTransactions::SqlDataDefinitionTransactions => { + "SQL_DATA_DEFINITION_TRANSACTIONS" + } + SqlSupportedTransactions::SqlDataManipulationTransactions => { + "SQL_DATA_MANIPULATION_TRANSACTIONS" + } } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2345,12 +2420,16 @@ impl SqlSupportedResultSetType { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlResultSetTypeUnspecified => "SQL_RESULT_SET_TYPE_UNSPECIFIED", - Self::SqlResultSetTypeForwardOnly => "SQL_RESULT_SET_TYPE_FORWARD_ONLY", - Self::SqlResultSetTypeScrollInsensitive => { + SqlSupportedResultSetType::SqlResultSetTypeUnspecified => { + "SQL_RESULT_SET_TYPE_UNSPECIFIED" + } + SqlSupportedResultSetType::SqlResultSetTypeForwardOnly => { + "SQL_RESULT_SET_TYPE_FORWARD_ONLY" + } + SqlSupportedResultSetType::SqlResultSetTypeScrollInsensitive => { "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE" } - Self::SqlResultSetTypeScrollSensitive => { + SqlSupportedResultSetType::SqlResultSetTypeScrollSensitive => { "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE" } } @@ -2384,13 +2463,13 @@ impl SqlSupportedResultSetConcurrency { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlResultSetConcurrencyUnspecified => { + SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUnspecified => { "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED" } - Self::SqlResultSetConcurrencyReadOnly => { + SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyReadOnly => { "SQL_RESULT_SET_CONCURRENCY_READ_ONLY" } - Self::SqlResultSetConcurrencyUpdatable => { + SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUpdatable => { "SQL_RESULT_SET_CONCURRENCY_UPDATABLE" } } @@ -2442,26 +2521,30 @@ impl SqlSupportsConvert { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::SqlConvertBigint => "SQL_CONVERT_BIGINT", - Self::SqlConvertBinary => "SQL_CONVERT_BINARY", - Self::SqlConvertBit => "SQL_CONVERT_BIT", - Self::SqlConvertChar => "SQL_CONVERT_CHAR", - Self::SqlConvertDate => "SQL_CONVERT_DATE", - Self::SqlConvertDecimal => "SQL_CONVERT_DECIMAL", - Self::SqlConvertFloat => "SQL_CONVERT_FLOAT", - Self::SqlConvertInteger => "SQL_CONVERT_INTEGER", - Self::SqlConvertIntervalDayTime => "SQL_CONVERT_INTERVAL_DAY_TIME", - Self::SqlConvertIntervalYearMonth => "SQL_CONVERT_INTERVAL_YEAR_MONTH", - Self::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY", - Self::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR", - Self::SqlConvertNumeric => "SQL_CONVERT_NUMERIC", - Self::SqlConvertReal => "SQL_CONVERT_REAL", - Self::SqlConvertSmallint => "SQL_CONVERT_SMALLINT", - Self::SqlConvertTime => "SQL_CONVERT_TIME", - Self::SqlConvertTimestamp => "SQL_CONVERT_TIMESTAMP", - Self::SqlConvertTinyint => "SQL_CONVERT_TINYINT", - Self::SqlConvertVarbinary => "SQL_CONVERT_VARBINARY", - Self::SqlConvertVarchar => "SQL_CONVERT_VARCHAR", + SqlSupportsConvert::SqlConvertBigint => "SQL_CONVERT_BIGINT", + SqlSupportsConvert::SqlConvertBinary => "SQL_CONVERT_BINARY", + SqlSupportsConvert::SqlConvertBit => "SQL_CONVERT_BIT", + SqlSupportsConvert::SqlConvertChar => "SQL_CONVERT_CHAR", + SqlSupportsConvert::SqlConvertDate => "SQL_CONVERT_DATE", + SqlSupportsConvert::SqlConvertDecimal => "SQL_CONVERT_DECIMAL", + SqlSupportsConvert::SqlConvertFloat => "SQL_CONVERT_FLOAT", + SqlSupportsConvert::SqlConvertInteger => "SQL_CONVERT_INTEGER", + SqlSupportsConvert::SqlConvertIntervalDayTime => { + "SQL_CONVERT_INTERVAL_DAY_TIME" + } + SqlSupportsConvert::SqlConvertIntervalYearMonth => { + "SQL_CONVERT_INTERVAL_YEAR_MONTH" + } + SqlSupportsConvert::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY", + SqlSupportsConvert::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR", + SqlSupportsConvert::SqlConvertNumeric => "SQL_CONVERT_NUMERIC", + SqlSupportsConvert::SqlConvertReal => "SQL_CONVERT_REAL", + SqlSupportsConvert::SqlConvertSmallint => "SQL_CONVERT_SMALLINT", + SqlSupportsConvert::SqlConvertTime => "SQL_CONVERT_TIME", + SqlSupportsConvert::SqlConvertTimestamp => "SQL_CONVERT_TIMESTAMP", + SqlSupportsConvert::SqlConvertTinyint => "SQL_CONVERT_TINYINT", + SqlSupportsConvert::SqlConvertVarbinary => "SQL_CONVERT_VARBINARY", + SqlSupportsConvert::SqlConvertVarchar => "SQL_CONVERT_VARCHAR", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2529,30 +2612,30 @@ impl XdbcDataType { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::XdbcUnknownType => "XDBC_UNKNOWN_TYPE", - Self::XdbcChar => "XDBC_CHAR", - Self::XdbcNumeric => "XDBC_NUMERIC", - Self::XdbcDecimal => "XDBC_DECIMAL", - Self::XdbcInteger => "XDBC_INTEGER", - Self::XdbcSmallint => "XDBC_SMALLINT", - Self::XdbcFloat => "XDBC_FLOAT", - Self::XdbcReal => "XDBC_REAL", - Self::XdbcDouble => "XDBC_DOUBLE", - Self::XdbcDatetime => "XDBC_DATETIME", - Self::XdbcInterval => "XDBC_INTERVAL", - Self::XdbcVarchar => "XDBC_VARCHAR", - Self::XdbcDate => "XDBC_DATE", - Self::XdbcTime => "XDBC_TIME", - Self::XdbcTimestamp => "XDBC_TIMESTAMP", - Self::XdbcLongvarchar => "XDBC_LONGVARCHAR", - Self::XdbcBinary => "XDBC_BINARY", - Self::XdbcVarbinary => "XDBC_VARBINARY", - Self::XdbcLongvarbinary => "XDBC_LONGVARBINARY", - Self::XdbcBigint => "XDBC_BIGINT", - Self::XdbcTinyint => "XDBC_TINYINT", - Self::XdbcBit => "XDBC_BIT", - Self::XdbcWchar => "XDBC_WCHAR", - Self::XdbcWvarchar => "XDBC_WVARCHAR", + XdbcDataType::XdbcUnknownType => "XDBC_UNKNOWN_TYPE", + XdbcDataType::XdbcChar => "XDBC_CHAR", + XdbcDataType::XdbcNumeric => "XDBC_NUMERIC", + XdbcDataType::XdbcDecimal => "XDBC_DECIMAL", + XdbcDataType::XdbcInteger => "XDBC_INTEGER", + XdbcDataType::XdbcSmallint => "XDBC_SMALLINT", + XdbcDataType::XdbcFloat => "XDBC_FLOAT", + XdbcDataType::XdbcReal => "XDBC_REAL", + XdbcDataType::XdbcDouble => "XDBC_DOUBLE", + XdbcDataType::XdbcDatetime => "XDBC_DATETIME", + XdbcDataType::XdbcInterval => "XDBC_INTERVAL", + XdbcDataType::XdbcVarchar => "XDBC_VARCHAR", + XdbcDataType::XdbcDate => "XDBC_DATE", + XdbcDataType::XdbcTime => "XDBC_TIME", + XdbcDataType::XdbcTimestamp => "XDBC_TIMESTAMP", + XdbcDataType::XdbcLongvarchar => "XDBC_LONGVARCHAR", + XdbcDataType::XdbcBinary => "XDBC_BINARY", + XdbcDataType::XdbcVarbinary => "XDBC_VARBINARY", + XdbcDataType::XdbcLongvarbinary => "XDBC_LONGVARBINARY", + XdbcDataType::XdbcBigint => "XDBC_BIGINT", + XdbcDataType::XdbcTinyint => "XDBC_TINYINT", + XdbcDataType::XdbcBit => "XDBC_BIT", + XdbcDataType::XdbcWchar => "XDBC_WCHAR", + XdbcDataType::XdbcWvarchar => "XDBC_WVARCHAR", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2626,39 +2709,57 @@ impl XdbcDatetimeSubcode { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN", - Self::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR", - Self::XdbcSubcodeTime => "XDBC_SUBCODE_TIME", - Self::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP", - Self::XdbcSubcodeTimeWithTimezone => "XDBC_SUBCODE_TIME_WITH_TIMEZONE", - Self::XdbcSubcodeTimestampWithTimezone => { + XdbcDatetimeSubcode::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN", + XdbcDatetimeSubcode::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR", + XdbcDatetimeSubcode::XdbcSubcodeTime => "XDBC_SUBCODE_TIME", + XdbcDatetimeSubcode::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP", + XdbcDatetimeSubcode::XdbcSubcodeTimeWithTimezone => { + "XDBC_SUBCODE_TIME_WITH_TIMEZONE" + } + XdbcDatetimeSubcode::XdbcSubcodeTimestampWithTimezone => { "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE" } - Self::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND", - Self::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH", - Self::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR", - Self::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE", - Self::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND", - Self::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE", - Self::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND", - Self::XdbcSubcodeMinuteToSecond => "XDBC_SUBCODE_MINUTE_TO_SECOND", - Self::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR", - Self::XdbcSubcodeIntervalMonth => "XDBC_SUBCODE_INTERVAL_MONTH", - Self::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY", - Self::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR", - Self::XdbcSubcodeIntervalMinute => "XDBC_SUBCODE_INTERVAL_MINUTE", - Self::XdbcSubcodeIntervalSecond => "XDBC_SUBCODE_INTERVAL_SECOND", - Self::XdbcSubcodeIntervalYearToMonth => "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH", - Self::XdbcSubcodeIntervalDayToHour => "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR", - Self::XdbcSubcodeIntervalDayToMinute => "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE", - Self::XdbcSubcodeIntervalDayToSecond => "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND", - Self::XdbcSubcodeIntervalHourToMinute => { + XdbcDatetimeSubcode::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND", + XdbcDatetimeSubcode::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH", + XdbcDatetimeSubcode::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR", + XdbcDatetimeSubcode::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE", + XdbcDatetimeSubcode::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND", + XdbcDatetimeSubcode::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE", + XdbcDatetimeSubcode::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND", + XdbcDatetimeSubcode::XdbcSubcodeMinuteToSecond => { + "XDBC_SUBCODE_MINUTE_TO_SECOND" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR", + XdbcDatetimeSubcode::XdbcSubcodeIntervalMonth => { + "XDBC_SUBCODE_INTERVAL_MONTH" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY", + XdbcDatetimeSubcode::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR", + XdbcDatetimeSubcode::XdbcSubcodeIntervalMinute => { + "XDBC_SUBCODE_INTERVAL_MINUTE" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalSecond => { + "XDBC_SUBCODE_INTERVAL_SECOND" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalYearToMonth => { + "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToHour => { + "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToMinute => { + "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToSecond => { + "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND" + } + XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToMinute => { "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE" } - Self::XdbcSubcodeIntervalHourToSecond => { + XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToSecond => { "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND" } - Self::XdbcSubcodeIntervalMinuteToSecond => { + XdbcDatetimeSubcode::XdbcSubcodeIntervalMinuteToSecond => { "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND" } } @@ -2733,9 +2834,9 @@ impl Nullable { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::NullabilityNoNulls => "NULLABILITY_NO_NULLS", - Self::NullabilityNullable => "NULLABILITY_NULLABLE", - Self::NullabilityUnknown => "NULLABILITY_UNKNOWN", + Nullable::NullabilityNoNulls => "NULLABILITY_NO_NULLS", + Nullable::NullabilityNullable => "NULLABILITY_NULLABLE", + Nullable::NullabilityUnknown => "NULLABILITY_UNKNOWN", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2776,10 +2877,10 @@ impl Searchable { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::None => "SEARCHABLE_NONE", - Self::Char => "SEARCHABLE_CHAR", - Self::Basic => "SEARCHABLE_BASIC", - Self::Full => "SEARCHABLE_FULL", + Searchable::None => "SEARCHABLE_NONE", + Searchable::Char => "SEARCHABLE_CHAR", + Searchable::Basic => "SEARCHABLE_BASIC", + Searchable::Full => "SEARCHABLE_FULL", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2809,11 +2910,11 @@ impl UpdateDeleteRules { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Cascade => "CASCADE", - Self::Restrict => "RESTRICT", - Self::SetNull => "SET_NULL", - Self::NoAction => "NO_ACTION", - Self::SetDefault => "SET_DEFAULT", + UpdateDeleteRules::Cascade => "CASCADE", + UpdateDeleteRules::Restrict => "RESTRICT", + UpdateDeleteRules::SetNull => "SET_NULL", + UpdateDeleteRules::NoAction => "NO_ACTION", + UpdateDeleteRules::SetDefault => "SET_DEFAULT", } } /// Creates an enum from field names used in the ProtoBuf definition. diff --git a/arrow-flight/tests/common/trailers_layer.rs b/arrow-flight/tests/common/trailers_layer.rs index 0ccb7df86c..b2ab74f7d9 100644 --- a/arrow-flight/tests/common/trailers_layer.rs +++ b/arrow-flight/tests/common/trailers_layer.rs @@ -21,7 +21,7 @@ use std::task::{Context, Poll}; use futures::ready; use http::{HeaderValue, Request, Response}; -use http_body::{Frame, SizeHint}; +use http_body::SizeHint; use pin_project_lite::pin_project; use tower::{Layer, Service}; @@ -99,19 +99,31 @@ impl<B: http_body::Body> http_body::Body for WrappedBody<B> { type Data = B::Data; type Error = B::Error; - fn poll_frame( - self: Pin<&mut Self>, + fn poll_data( + mut self: Pin<&mut Self>, cx: &mut Context<'_>, - ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> { - let mut result = ready!(self.project().inner.poll_frame(cx)); + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + self.as_mut().project().inner.poll_data(cx) + } + + fn poll_trailers( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<http::header::HeaderMap>, Self::Error>> { + let result: Result<Option<http::header::HeaderMap>, Self::Error> = + ready!(self.as_mut().project().inner.poll_trailers(cx)); + + let mut trailers = http::header::HeaderMap::new(); + trailers.insert("test-trailer", HeaderValue::from_static("trailer_val")); - if let Some(Ok(frame)) = &mut result { - if let Some(trailers) = frame.trailers_mut() { - trailers.insert("test-trailer", HeaderValue::from_static("trailer_val")); + match result { + Ok(Some(mut existing)) => { + existing.extend(trailers.iter().map(|(k, v)| (k.clone(), v.clone()))); + Poll::Ready(Ok(Some(existing))) } + Ok(None) => Poll::Ready(Ok(Some(trailers))), + Err(e) => Poll::Ready(Err(e)), } - - Poll::Ready(result) } fn is_end_stream(&self) -> bool { diff --git a/arrow-integration-testing/Cargo.toml b/arrow-integration-testing/Cargo.toml index 7be56d9198..032b99f4fb 100644 --- a/arrow-integration-testing/Cargo.toml +++ b/arrow-integration-testing/Cargo.toml @@ -42,11 +42,11 @@ async-trait = { version = "0.1.41", default-features = false } clap = { version = "4", default-features = false, features = ["std", "derive", "help", "error-context", "usage"] } futures = { version = "0.3", default-features = false } hex = { version = "0.4", default-features = false, features = ["std"] } -prost = { version = "0.13", default-features = false } +prost = { version = "0.12", default-features = false } serde = { version = "1.0", default-features = false, features = ["rc", "derive"] } serde_json = { version = "1.0", default-features = false, features = ["std"] } tokio = { version = "1.0", default-features = false } -tonic = { version = "0.12", default-features = false } +tonic = { version = "0.11", default-features = false } tracing-subscriber = { version = "0.3.1", default-features = false, features = ["fmt"], optional = true } num = { version = "0.4", default-features = false, features = ["std"] } flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
