You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by al...@apache.org on 2022/04/07 19:30:50 UTC
[arrow-rs] branch master updated: chore: Update `prost`, `prost-derive` and `prost-types` to 0.10, `tonic`, and `tonic-build` to `0.7` (#1510)
This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/master by this push:
new c7c7af6a5 chore: Update `prost`, `prost-derive` and `prost-types` to 0.10, `tonic`, and `tonic-build` to `0.7` (#1510)
c7c7af6a5 is described below
commit c7c7af6a50665ed1f5e06e72916b15893ffced47
Author: Andrew Lamb <an...@nerdnetworks.org>
AuthorDate: Thu Apr 7 15:30:46 2022 -0400
chore: Update `prost`, `prost-derive` and `prost-types` to 0.10, `tonic`, and `tonic-build` to `0.7` (#1510)
* chore: Update prost, prost-derive and prost-types to 0.10
* Update tonic requirement from 0.6 to 0.7
Updates the requirements on [tonic](https://github.com/hyperium/tonic) to permit the latest version.
- [Release notes](https://github.com/hyperium/tonic/releases)
- [Changelog](https://github.com/hyperium/tonic/blob/master/CHANGELOG.md)
- [Commits](https://github.com/hyperium/tonic/compare/v0.6.0...v0.7.0)
---
updated-dependencies:
- dependency-name: tonic
dependency-type: direct:production
...
Signed-off-by: dependabot[bot] <su...@github.com>
* Update tonic-build requirement from 0.6 to 0.7
Updates the requirements on [tonic-build](https://github.com/hyperium/tonic) to permit the latest version.
- [Release notes](https://github.com/hyperium/tonic/releases)
- [Changelog](https://github.com/hyperium/tonic/blob/master/CHANGELOG.md)
- [Commits](https://github.com/hyperium/tonic/compare/v0.6.0...v0.7.0)
---
updated-dependencies:
- dependency-name: tonic-build
dependency-type: direct:production
...
Signed-off-by: dependabot[bot] <su...@github.com>
* Update generated code
* Try installing cmake dependencies for flight
* install cmake and protobuf
* Use --experimental_allow_proto3_optional flag
* fix apt-install
* try to install just protobuf compiler
* Add action to configure workspace
* Use prost enabled toolchain
* fixes
* fixups
* fix clippy
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
---
.github/actions/setup-builder/action.yaml | 39 ++
.github/workflows/rust.yml | 51 +-
arrow-flight/Cargo.toml | 10 +-
arrow-flight/build.rs | 18 +-
arrow-flight/src/arrow.flight.protocol.rs | 717 ++++++++++++----------
arrow-flight/src/sql/arrow.flight.protocol.sql.rs | 158 ++---
integration-testing/Cargo.toml | 4 +-
7 files changed, 532 insertions(+), 465 deletions(-)
diff --git a/.github/actions/setup-builder/action.yaml b/.github/actions/setup-builder/action.yaml
new file mode 100644
index 000000000..13a3008b7
--- /dev/null
+++ b/.github/actions/setup-builder/action.yaml
@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: Prepare Rust Builder
+description: 'Prepare Rust Build Environment'
+inputs:
+ rust-version:
+ description: 'version of rust to install (e.g. stable)'
+ required: true
+ default: 'stable'
+runs:
+ using: "composite"
+ steps:
+ - name: Install Build Dependencies
+ shell: bash
+ run: |
+ apt-get update
+ apt-get install -y protobuf-compiler
+ - name: Setup Rust toolchain
+ shell: bash
+ run: |
+ echo "Installing ${{ inputs.rust-version }}"
+ rustup toolchain install ${{ inputs.rust-version }}
+ rustup default ${{ inputs.rust-version }}
+ rustup component add rustfmt
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 9b447a2f4..e28ebe6e1 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -55,11 +55,9 @@ jobs:
path: /github/home/target
key: ${{ runner.os }}-${{ matrix.arch }}-target-cache3-${{ matrix.rust }}-
- name: Setup Rust toolchain
- run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup default ${{ matrix.rust }}
- rustup component add rustfmt
-
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
- name: Build Workspace
run: |
export CARGO_HOME="/github/home/.cargo"
@@ -100,10 +98,9 @@ jobs:
# this key equals the ones on `linux-build-lib` for re-use
key: ${{ runner.os }}-${{ matrix.arch }}-target-cache3-${{ matrix.rust }}
- name: Setup Rust toolchain
- run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup default ${{ matrix.rust }}
- rustup component add rustfmt
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
- name: Run tests
run: |
export CARGO_HOME="/github/home/.cargo"
@@ -165,10 +162,9 @@ jobs:
path: /github/home/target
key: ${{ runner.os }}-${{ matrix.arch }}-target-nightly-cache3-${{ matrix.rust }}
- name: Setup Rust toolchain
- run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup default ${{ matrix.rust }}
- rustup component add rustfmt
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
- name: Run tests
run: |
export CARGO_HOME="/github/home/.cargo"
@@ -240,9 +236,11 @@ jobs:
# this key equals the ones on `linux-build-lib` for re-use
key: ${{ runner.os }}-${{ matrix.arch }}-target-cache3-${{ matrix.rust }}
- name: Setup Rust toolchain
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
+ - name: Setup Clippy
run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup default ${{ matrix.rust }}
rustup component add rustfmt clippy
- name: Run clippy
run: |
@@ -280,10 +278,9 @@ jobs:
# this key equals the ones on `linux-build-lib` for re-use
key: ${{ runner.os }}-${{ matrix.arch }}-target-cache3-${{ matrix.rust }}
- name: Setup Rust toolchain
- run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup default ${{ matrix.rust }}
- rustup component add rustfmt clippy
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
- name: Check benchmarks
run: |
export CARGO_HOME="/github/home/.cargo"
@@ -379,7 +376,7 @@ jobs:
with:
path: /github/home/target
key: ${{ runner.os }}-${{ matrix.arch }}-target-wasm32-cache3-${{ matrix.rust }}
- - name: Setup Rust toolchain
+ - name: Setup Rust toolchain for WASM
run: |
rustup toolchain install ${{ matrix.rust }}
rustup override set ${{ matrix.rust }}
@@ -427,10 +424,9 @@ jobs:
path: /github/home/target
key: ${{ runner.os }}-${{ matrix.arch }}-target-nightly-cache3-${{ matrix.rust }}
- name: Setup Rust toolchain
- run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup default ${{ matrix.rust }}
- rustup component add rustfmt
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
- name: Run cargo doc
run: |
export CARGO_HOME="/github/home/.cargo"
@@ -467,10 +463,9 @@ jobs:
# this key equals the ones on `linux-build-lib` for re-use
key: ${{ runner.os }}-${{ matrix.arch }}-target-cache3-${{ matrix.rust }}
- name: Setup Rust toolchain
- run: |
- rustup toolchain install ${{ matrix.rust }}
- rustup override set ${{ matrix.rust }}
- rustup component add rustfmt
+ uses: ./.github/actions/setup-builder
+ with:
+ rust-version: ${{ matrix.rust }}
- name: Arrow Build with default features
run: |
export CARGO_HOME="/github/home/.cargo"
diff --git a/arrow-flight/Cargo.toml b/arrow-flight/Cargo.toml
index d99102529..682e5206b 100644
--- a/arrow-flight/Cargo.toml
+++ b/arrow-flight/Cargo.toml
@@ -29,11 +29,11 @@ license = "Apache-2.0"
[dependencies]
arrow = { path = "../arrow", version = "11.1.0" }
base64 = "0.13"
-tonic = "0.6"
+tonic = "0.7"
bytes = "1"
-prost = "0.9"
-prost-types = { version = "0.9.0", optional = true }
-prost-derive = "0.9"
+prost = "0.10"
+prost-types = { version = "0.10.0", optional = true }
+prost-derive = "0.10"
tokio = { version = "1.0", features = ["macros", "rt", "rt-multi-thread"] }
futures = { version = "0.3", default-features = false, features = ["alloc"]}
@@ -44,7 +44,7 @@ flight-sql-experimental = ["prost-types"]
[dev-dependencies]
[build-dependencies]
-tonic-build = "0.6"
+tonic-build = "0.7"
# Pin specific version of the tonic-build dependencies to avoid auto-generated
# (and checked in) arrow.flight.protocol.rs from changing
proc-macro2 = ">1.0.30"
diff --git a/arrow-flight/build.rs b/arrow-flight/build.rs
index 3df4efad8..2054f8e71 100644
--- a/arrow-flight/build.rs
+++ b/arrow-flight/build.rs
@@ -33,7 +33,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
// avoid rerunning build if the file has not changed
println!("cargo:rerun-if-changed=../format/Flight.proto");
- tonic_build::compile_protos("../format/Flight.proto")?;
+ let proto_dir = Path::new("../format");
+ let proto_path = Path::new("../format/Flight.proto");
+
+ tonic_build::configure()
+ // protoc in unbuntu builder needs this option
+ .protoc_arg("--experimental_allow_proto3_optional")
+ .compile(&[proto_path], &[proto_dir])?;
+
// read file contents to string
let mut file = OpenOptions::new()
.read(true)
@@ -58,7 +65,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
// avoid rerunning build if the file has not changed
println!("cargo:rerun-if-changed=../format/FlightSql.proto");
- tonic_build::compile_protos("../format/FlightSql.proto")?;
+ let proto_dir = Path::new("../format");
+ let proto_path = Path::new("../format/FlightSql.proto");
+
+ tonic_build::configure()
+ // protoc in unbuntu builder needs this option
+ .protoc_arg("--experimental_allow_proto3_optional")
+ .compile(&[proto_path], &[proto_dir])?;
+
// read file contents to string
let mut file = OpenOptions::new()
.read(true)
diff --git a/arrow-flight/src/arrow.flight.protocol.rs b/arrow-flight/src/arrow.flight.protocol.rs
index 5775c0177..bbca033fd 100644
--- a/arrow-flight/src/arrow.flight.protocol.rs
+++ b/arrow-flight/src/arrow.flight.protocol.rs
@@ -6,43 +6,44 @@
pub struct HandshakeRequest {
///
/// A defined protocol version
- #[prost(uint64, tag = "1")]
+ #[prost(uint64, tag="1")]
pub protocol_version: u64,
///
/// Arbitrary auth/handshake info.
- #[prost(bytes = "vec", tag = "2")]
+ #[prost(bytes="vec", tag="2")]
pub payload: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HandshakeResponse {
///
/// A defined protocol version
- #[prost(uint64, tag = "1")]
+ #[prost(uint64, tag="1")]
pub protocol_version: u64,
///
/// Arbitrary auth/handshake info.
- #[prost(bytes = "vec", tag = "2")]
+ #[prost(bytes="vec", tag="2")]
pub payload: ::prost::alloc::vec::Vec<u8>,
}
///
/// A message for doing simple auth.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BasicAuth {
- #[prost(string, tag = "2")]
+ #[prost(string, tag="2")]
pub username: ::prost::alloc::string::String,
- #[prost(string, tag = "3")]
+ #[prost(string, tag="3")]
pub password: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Empty {}
+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.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionType {
- #[prost(string, tag = "1")]
+ #[prost(string, tag="1")]
pub r#type: ::prost::alloc::string::String,
- #[prost(string, tag = "2")]
+ #[prost(string, tag="2")]
pub description: ::prost::alloc::string::String,
}
///
@@ -50,23 +51,23 @@ pub struct ActionType {
/// of available Arrow Flight streams.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Criteria {
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub expression: ::prost::alloc::vec::Vec<u8>,
}
///
/// An opaque action specific for the service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Action {
- #[prost(string, tag = "1")]
+ #[prost(string, tag="1")]
pub r#type: ::prost::alloc::string::String,
- #[prost(bytes = "vec", tag = "2")]
+ #[prost(bytes="vec", tag="2")]
pub body: ::prost::alloc::vec::Vec<u8>,
}
///
/// An opaque result returned after executing an action.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Result {
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub body: ::prost::alloc::vec::Vec<u8>,
}
///
@@ -74,7 +75,7 @@ pub struct Result {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SchemaResult {
/// schema of the dataset as described in Schema.fbs::Schema.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub schema: ::prost::alloc::vec::Vec<u8>,
}
///
@@ -82,26 +83,24 @@ pub struct SchemaResult {
/// a flight or be used to expose a set of previously defined flights.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FlightDescriptor {
- #[prost(enumeration = "flight_descriptor::DescriptorType", tag = "1")]
+ #[prost(enumeration="flight_descriptor::DescriptorType", tag="1")]
pub r#type: i32,
///
/// Opaque value used to express a command. Should only be defined when
/// type = CMD.
- #[prost(bytes = "vec", tag = "2")]
+ #[prost(bytes="vec", tag="2")]
pub cmd: ::prost::alloc::vec::Vec<u8>,
///
/// List of strings identifying a particular dataset. Should only be defined
/// when type = PATH.
- #[prost(string, repeated, tag = "3")]
+ #[prost(string, repeated, tag="3")]
pub path: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `FlightDescriptor`.
pub mod flight_descriptor {
///
/// Describes what type of descriptor is defined.
- #[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
- )]
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DescriptorType {
/// Protobuf pattern, not used.
@@ -122,21 +121,21 @@ pub mod flight_descriptor {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FlightInfo {
/// schema of the dataset as described in Schema.fbs::Schema.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub schema: ::prost::alloc::vec::Vec<u8>,
///
/// The descriptor associated with this info.
- #[prost(message, optional, tag = "2")]
+ #[prost(message, optional, tag="2")]
pub flight_descriptor: ::core::option::Option<FlightDescriptor>,
///
/// A list of endpoints associated with the flight. To consume the whole
/// flight, all endpoints must be consumed.
- #[prost(message, repeated, tag = "3")]
+ #[prost(message, repeated, tag="3")]
pub endpoint: ::prost::alloc::vec::Vec<FlightEndpoint>,
/// Set these to -1 if unknown.
- #[prost(int64, tag = "4")]
+ #[prost(int64, tag="4")]
pub total_records: i64,
- #[prost(int64, tag = "5")]
+ #[prost(int64, tag="5")]
pub total_bytes: i64,
}
///
@@ -145,13 +144,13 @@ pub struct FlightInfo {
pub struct FlightEndpoint {
///
/// Token used to retrieve this stream.
- #[prost(message, optional, tag = "1")]
+ #[prost(message, optional, tag="1")]
pub ticket: ::core::option::Option<Ticket>,
///
/// A list of URIs where this ticket can be redeemed. If the list is
/// empty, the expectation is that the ticket can only be redeemed on the
/// current service where the ticket was generated.
- #[prost(message, repeated, tag = "2")]
+ #[prost(message, repeated, tag="2")]
pub location: ::prost::alloc::vec::Vec<Location>,
}
///
@@ -159,7 +158,7 @@ pub struct FlightEndpoint {
/// stream given a ticket.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Location {
- #[prost(string, tag = "1")]
+ #[prost(string, tag="1")]
pub uri: ::prost::alloc::string::String,
}
///
@@ -167,7 +166,7 @@ pub struct Location {
/// portion of a stream.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Ticket {
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub ticket: ::prost::alloc::vec::Vec<u8>,
}
///
@@ -177,46 +176,46 @@ pub struct FlightData {
///
/// The descriptor of the data. This is only relevant when a client is
/// starting a new DoPut stream.
- #[prost(message, optional, tag = "1")]
+ #[prost(message, optional, tag="1")]
pub flight_descriptor: ::core::option::Option<FlightDescriptor>,
///
/// Header for message data as described in Message.fbs::Message.
- #[prost(bytes = "vec", tag = "2")]
+ #[prost(bytes="vec", tag="2")]
pub data_header: ::prost::alloc::vec::Vec<u8>,
///
/// Application-defined metadata.
- #[prost(bytes = "vec", tag = "3")]
+ #[prost(bytes="vec", tag="3")]
pub app_metadata: ::prost::alloc::vec::Vec<u8>,
///
/// The actual batch of Arrow data. Preferably handled with minimal-copies
/// coming last in the definition to help with sidecar patterns (it is
/// expected that some implementations will fetch this field off the wire
/// with specialized code to avoid extra memory copies).
- #[prost(bytes = "vec", tag = "1000")]
+ #[prost(bytes="vec", tag="1000")]
pub data_body: ::prost::alloc::vec::Vec<u8>,
}
///*
/// The response message associated with the submission of a DoPut.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PutResult {
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub app_metadata: ::prost::alloc::vec::Vec<u8>,
}
-#[doc = r" Generated client implementations."]
+/// Generated client implementations.
pub mod flight_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
- #[doc = ""]
- #[doc = " A flight service is an endpoint for retrieving or storing Arrow data. A"]
- #[doc = " flight service can expose one or more predefined endpoints that can be"]
- #[doc = " accessed using the Arrow Flight Protocol. Additionally, a flight service"]
- #[doc = " can expose a set of actions that are available."]
+ ///
+ /// A flight service is an endpoint for retrieving or storing Arrow data. A
+ /// flight service can expose one or more predefined endpoints that can be
+ /// accessed using the Arrow Flight Protocol. Additionally, a flight service
+ /// can expose a set of actions that are available.
#[derive(Debug, Clone)]
pub struct FlightServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl FlightServiceClient<tonic::transport::Channel> {
- #[doc = r" Attempt to create a new client by connecting to a given endpoint."]
+ /// Attempt to create a new client by connecting to a given endpoint.
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: std::convert::TryInto<tonic::transport::Endpoint>,
@@ -229,8 +228,8 @@ pub mod flight_service_client {
impl<T> FlightServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
- T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
+ T::ResponseBody: Default + Body<Data = Bytes> + Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
@@ -249,394 +248,426 @@ pub mod flight_service_client {
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
- <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
- Into<StdError> + Send + Sync,
+ <T as tonic::codegen::Service<
+ http::Request<tonic::body::BoxBody>,
+ >>::Error: Into<StdError> + Send + Sync,
{
FlightServiceClient::new(InterceptedService::new(inner, interceptor))
}
- #[doc = r" Compress requests with `gzip`."]
- #[doc = r""]
- #[doc = r" This requires the server to support it otherwise it might respond with an"]
- #[doc = r" error."]
+ /// Compress requests with `gzip`.
+ ///
+ /// This requires the server to support it otherwise it might respond with an
+ /// error.
+ #[must_use]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
- #[doc = r" Enable decompressing responses with `gzip`."]
+ /// Enable decompressing responses with `gzip`.
+ #[must_use]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
- #[doc = ""]
- #[doc = " Handshake between client and server. Depending on the server, the"]
- #[doc = " handshake may be required to determine the token that should be used for"]
- #[doc = " future operations. Both request and response are streams to allow multiple"]
- #[doc = " round-trips depending on auth mechanism."]
+ ///
+ /// Handshake between client and server. Depending on the server, the
+ /// handshake may be required to determine the token that should be used for
+ /// future operations. Both request and response are streams to allow multiple
+ /// round-trips depending on auth mechanism.
pub async fn handshake(
&mut self,
request: impl tonic::IntoStreamingRequest<Message = super::HandshakeRequest>,
) -> Result<
- tonic::Response<tonic::codec::Streaming<super::HandshakeResponse>>,
- tonic::Status,
- > {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ tonic::Response<tonic::codec::Streaming<super::HandshakeResponse>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/Handshake",
);
- self.inner
- .streaming(request.into_streaming_request(), path, codec)
- .await
+ self.inner.streaming(request.into_streaming_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " Get a list of available streams given a particular criteria. Most flight"]
- #[doc = " services will expose one or more streams that are readily available for"]
- #[doc = " retrieval. This api allows listing the streams available for"]
- #[doc = " consumption. A user can also provide a criteria. The criteria can limit"]
- #[doc = " the subset of streams that can be listed via this interface. Each flight"]
- #[doc = " service allows its own definition of how to consume criteria."]
+ ///
+ /// Get a list of available streams given a particular criteria. Most flight
+ /// services will expose one or more streams that are readily available for
+ /// retrieval. This api allows listing the streams available for
+ /// consumption. A user can also provide a criteria. The criteria can limit
+ /// the subset of streams that can be listed via this interface. Each flight
+ /// service allows its own definition of how to consume criteria.
pub async fn list_flights(
&mut self,
request: impl tonic::IntoRequest<super::Criteria>,
) -> Result<
- tonic::Response<tonic::codec::Streaming<super::FlightInfo>>,
- tonic::Status,
- > {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ tonic::Response<tonic::codec::Streaming<super::FlightInfo>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/ListFlights",
);
- self.inner
- .server_streaming(request.into_request(), path, codec)
- .await
+ self.inner.server_streaming(request.into_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " For a given FlightDescriptor, get information about how the flight can be"]
- #[doc = " consumed. This is a useful interface if the consumer of the interface"]
- #[doc = " already can identify the specific flight to consume. This interface can"]
- #[doc = " also allow a consumer to generate a flight stream through a specified"]
- #[doc = " descriptor. For example, a flight descriptor might be something that"]
- #[doc = " includes a SQL statement or a Pickled Python operation that will be"]
- #[doc = " executed. In those cases, the descriptor will not be previously available"]
- #[doc = " within the list of available streams provided by ListFlights but will be"]
- #[doc = " available for consumption for the duration defined by the specific flight"]
- #[doc = " service."]
+ ///
+ /// For a given FlightDescriptor, get information about how the flight can be
+ /// consumed. This is a useful interface if the consumer of the interface
+ /// already can identify the specific flight to consume. This interface can
+ /// also allow a consumer to generate a flight stream through a specified
+ /// descriptor. For example, a flight descriptor might be something that
+ /// includes a SQL statement or a Pickled Python operation that will be
+ /// executed. In those cases, the descriptor will not be previously available
+ /// within the list of available streams provided by ListFlights but will be
+ /// available for consumption for the duration defined by the specific flight
+ /// service.
pub async fn get_flight_info(
&mut self,
request: impl tonic::IntoRequest<super::FlightDescriptor>,
) -> Result<tonic::Response<super::FlightInfo>, tonic::Status> {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/GetFlightInfo",
);
self.inner.unary(request.into_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema"]
- #[doc = " This is used when a consumer needs the Schema of flight stream. Similar to"]
- #[doc = " GetFlightInfo this interface may generate a new flight that was not previously"]
- #[doc = " available in ListFlights."]
+ ///
+ /// For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
+ /// This is used when a consumer needs the Schema of flight stream. Similar to
+ /// GetFlightInfo this interface may generate a new flight that was not previously
+ /// available in ListFlights.
pub async fn get_schema(
&mut self,
request: impl tonic::IntoRequest<super::FlightDescriptor>,
) -> Result<tonic::Response<super::SchemaResult>, tonic::Status> {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/GetSchema",
);
self.inner.unary(request.into_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " Retrieve a single stream associated with a particular descriptor"]
- #[doc = " associated with the referenced ticket. A Flight can be composed of one or"]
- #[doc = " more streams where each stream can be retrieved using a separate opaque"]
- #[doc = " ticket that the flight service uses for managing a collection of streams."]
+ ///
+ /// Retrieve a single stream associated with a particular descriptor
+ /// associated with the referenced ticket. A Flight can be composed of one or
+ /// more streams where each stream can be retrieved using a separate opaque
+ /// ticket that the flight service uses for managing a collection of streams.
pub async fn do_get(
&mut self,
request: impl tonic::IntoRequest<super::Ticket>,
) -> Result<
- tonic::Response<tonic::codec::Streaming<super::FlightData>>,
- tonic::Status,
- > {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ tonic::Response<tonic::codec::Streaming<super::FlightData>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/DoGet",
);
- self.inner
- .server_streaming(request.into_request(), path, codec)
- .await
+ self.inner.server_streaming(request.into_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " Push a stream to the flight service associated with a particular"]
- #[doc = " flight stream. This allows a client of a flight service to upload a stream"]
- #[doc = " of data. Depending on the particular flight service, a client consumer"]
- #[doc = " could be allowed to upload a single stream per descriptor or an unlimited"]
- #[doc = " number. In the latter, the service might implement a 'seal' action that"]
- #[doc = " can be applied to a descriptor once all streams are uploaded."]
+ ///
+ /// Push a stream to the flight service associated with a particular
+ /// flight stream. This allows a client of a flight service to upload a stream
+ /// of data. Depending on the particular flight service, a client consumer
+ /// could be allowed to upload a single stream per descriptor or an unlimited
+ /// number. In the latter, the service might implement a 'seal' action that
+ /// can be applied to a descriptor once all streams are uploaded.
pub async fn do_put(
&mut self,
request: impl tonic::IntoStreamingRequest<Message = super::FlightData>,
) -> Result<
- tonic::Response<tonic::codec::Streaming<super::PutResult>>,
- tonic::Status,
- > {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ tonic::Response<tonic::codec::Streaming<super::PutResult>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/DoPut",
);
- self.inner
- .streaming(request.into_streaming_request(), path, codec)
- .await
+ self.inner.streaming(request.into_streaming_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " Open a bidirectional data channel for a given descriptor. This"]
- #[doc = " allows clients to send and receive arbitrary Arrow data and"]
- #[doc = " application-specific metadata in a single logical stream. In"]
- #[doc = " contrast to DoGet/DoPut, this is more suited for clients"]
- #[doc = " offloading computation (rather than storage) to a Flight service."]
+ ///
+ /// Open a bidirectional data channel for a given descriptor. This
+ /// allows clients to send and receive arbitrary Arrow data and
+ /// application-specific metadata in a single logical stream. In
+ /// contrast to DoGet/DoPut, this is more suited for clients
+ /// offloading computation (rather than storage) to a Flight service.
pub async fn do_exchange(
&mut self,
request: impl tonic::IntoStreamingRequest<Message = super::FlightData>,
) -> Result<
- tonic::Response<tonic::codec::Streaming<super::FlightData>>,
- tonic::Status,
- > {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ tonic::Response<tonic::codec::Streaming<super::FlightData>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/DoExchange",
);
- self.inner
- .streaming(request.into_streaming_request(), path, codec)
- .await
+ self.inner.streaming(request.into_streaming_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " Flight services can support an arbitrary number of simple actions in"]
- #[doc = " addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut"]
- #[doc = " operations that are potentially available. DoAction allows a flight client"]
- #[doc = " to do a specific action against a flight service. An action includes"]
- #[doc = " opaque request and response objects that are specific to the type action"]
- #[doc = " being undertaken."]
+ ///
+ /// Flight services can support an arbitrary number of simple actions in
+ /// addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
+ /// operations that are potentially available. DoAction allows a flight client
+ /// to do a specific action against a flight service. An action includes
+ /// opaque request and response objects that are specific to the type action
+ /// being undertaken.
pub async fn do_action(
&mut self,
request: impl tonic::IntoRequest<super::Action>,
- ) -> Result<tonic::Response<tonic::codec::Streaming<super::Result>>, tonic::Status>
- {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ ) -> Result<
+ tonic::Response<tonic::codec::Streaming<super::Result>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/DoAction",
);
- self.inner
- .server_streaming(request.into_request(), path, codec)
- .await
+ self.inner.server_streaming(request.into_request(), path, codec).await
}
- #[doc = ""]
- #[doc = " A flight service exposes all of the available action types that it has"]
- #[doc = " along with descriptions. This allows different flight consumers to"]
- #[doc = " understand the capabilities of the flight service."]
+ ///
+ /// A flight service exposes all of the available action types that it has
+ /// along with descriptions. This allows different flight consumers to
+ /// understand the capabilities of the flight service.
pub async fn list_actions(
&mut self,
request: impl tonic::IntoRequest<super::Empty>,
) -> Result<
- tonic::Response<tonic::codec::Streaming<super::ActionType>>,
- tonic::Status,
- > {
- self.inner.ready().await.map_err(|e| {
- tonic::Status::new(
- tonic::Code::Unknown,
- format!("Service was not ready: {}", e.into()),
- )
- })?;
+ tonic::Response<tonic::codec::Streaming<super::ActionType>>,
+ tonic::Status,
+ > {
+ self.inner
+ .ready()
+ .await
+ .map_err(|e| {
+ tonic::Status::new(
+ tonic::Code::Unknown,
+ format!("Service was not ready: {}", e.into()),
+ )
+ })?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arrow.flight.protocol.FlightService/ListActions",
);
- self.inner
- .server_streaming(request.into_request(), path, codec)
- .await
+ self.inner.server_streaming(request.into_request(), path, codec).await
}
}
}
-#[doc = r" Generated server implementations."]
+/// Generated server implementations.
pub mod flight_service_server {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
- #[doc = "Generated trait containing gRPC methods that should be implemented for use with FlightServiceServer."]
+ ///Generated trait containing gRPC methods that should be implemented for use with FlightServiceServer.
#[async_trait]
pub trait FlightService: Send + Sync + 'static {
- #[doc = "Server streaming response type for the Handshake method."]
- type HandshakeStream: futures_core::Stream<Item = Result<super::HandshakeResponse, tonic::Status>>
+ ///Server streaming response type for the Handshake method.
+ type HandshakeStream: futures_core::Stream<
+ Item = Result<super::HandshakeResponse, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " Handshake between client and server. Depending on the server, the"]
- #[doc = " handshake may be required to determine the token that should be used for"]
- #[doc = " future operations. Both request and response are streams to allow multiple"]
- #[doc = " round-trips depending on auth mechanism."]
+ ///
+ /// Handshake between client and server. Depending on the server, the
+ /// handshake may be required to determine the token that should be used for
+ /// future operations. Both request and response are streams to allow multiple
+ /// round-trips depending on auth mechanism.
async fn handshake(
&self,
request: tonic::Request<tonic::Streaming<super::HandshakeRequest>>,
) -> Result<tonic::Response<Self::HandshakeStream>, tonic::Status>;
- #[doc = "Server streaming response type for the ListFlights method."]
- type ListFlightsStream: futures_core::Stream<Item = Result<super::FlightInfo, tonic::Status>>
+ ///Server streaming response type for the ListFlights method.
+ type ListFlightsStream: futures_core::Stream<
+ Item = Result<super::FlightInfo, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " Get a list of available streams given a particular criteria. Most flight"]
- #[doc = " services will expose one or more streams that are readily available for"]
- #[doc = " retrieval. This api allows listing the streams available for"]
- #[doc = " consumption. A user can also provide a criteria. The criteria can limit"]
- #[doc = " the subset of streams that can be listed via this interface. Each flight"]
- #[doc = " service allows its own definition of how to consume criteria."]
+ ///
+ /// Get a list of available streams given a particular criteria. Most flight
+ /// services will expose one or more streams that are readily available for
+ /// retrieval. This api allows listing the streams available for
+ /// consumption. A user can also provide a criteria. The criteria can limit
+ /// the subset of streams that can be listed via this interface. Each flight
+ /// service allows its own definition of how to consume criteria.
async fn list_flights(
&self,
request: tonic::Request<super::Criteria>,
) -> Result<tonic::Response<Self::ListFlightsStream>, tonic::Status>;
- #[doc = ""]
- #[doc = " For a given FlightDescriptor, get information about how the flight can be"]
- #[doc = " consumed. This is a useful interface if the consumer of the interface"]
- #[doc = " already can identify the specific flight to consume. This interface can"]
- #[doc = " also allow a consumer to generate a flight stream through a specified"]
- #[doc = " descriptor. For example, a flight descriptor might be something that"]
- #[doc = " includes a SQL statement or a Pickled Python operation that will be"]
- #[doc = " executed. In those cases, the descriptor will not be previously available"]
- #[doc = " within the list of available streams provided by ListFlights but will be"]
- #[doc = " available for consumption for the duration defined by the specific flight"]
- #[doc = " service."]
+ ///
+ /// For a given FlightDescriptor, get information about how the flight can be
+ /// consumed. This is a useful interface if the consumer of the interface
+ /// already can identify the specific flight to consume. This interface can
+ /// also allow a consumer to generate a flight stream through a specified
+ /// descriptor. For example, a flight descriptor might be something that
+ /// includes a SQL statement or a Pickled Python operation that will be
+ /// executed. In those cases, the descriptor will not be previously available
+ /// within the list of available streams provided by ListFlights but will be
+ /// available for consumption for the duration defined by the specific flight
+ /// service.
async fn get_flight_info(
&self,
request: tonic::Request<super::FlightDescriptor>,
) -> Result<tonic::Response<super::FlightInfo>, tonic::Status>;
- #[doc = ""]
- #[doc = " For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema"]
- #[doc = " This is used when a consumer needs the Schema of flight stream. Similar to"]
- #[doc = " GetFlightInfo this interface may generate a new flight that was not previously"]
- #[doc = " available in ListFlights."]
+ ///
+ /// For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
+ /// This is used when a consumer needs the Schema of flight stream. Similar to
+ /// GetFlightInfo this interface may generate a new flight that was not previously
+ /// available in ListFlights.
async fn get_schema(
&self,
request: tonic::Request<super::FlightDescriptor>,
) -> Result<tonic::Response<super::SchemaResult>, tonic::Status>;
- #[doc = "Server streaming response type for the DoGet method."]
- type DoGetStream: futures_core::Stream<Item = Result<super::FlightData, tonic::Status>>
+ ///Server streaming response type for the DoGet method.
+ type DoGetStream: futures_core::Stream<
+ Item = Result<super::FlightData, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " Retrieve a single stream associated with a particular descriptor"]
- #[doc = " associated with the referenced ticket. A Flight can be composed of one or"]
- #[doc = " more streams where each stream can be retrieved using a separate opaque"]
- #[doc = " ticket that the flight service uses for managing a collection of streams."]
+ ///
+ /// Retrieve a single stream associated with a particular descriptor
+ /// associated with the referenced ticket. A Flight can be composed of one or
+ /// more streams where each stream can be retrieved using a separate opaque
+ /// ticket that the flight service uses for managing a collection of streams.
async fn do_get(
&self,
request: tonic::Request<super::Ticket>,
) -> Result<tonic::Response<Self::DoGetStream>, tonic::Status>;
- #[doc = "Server streaming response type for the DoPut method."]
- type DoPutStream: futures_core::Stream<Item = Result<super::PutResult, tonic::Status>>
+ ///Server streaming response type for the DoPut method.
+ type DoPutStream: futures_core::Stream<
+ Item = Result<super::PutResult, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " Push a stream to the flight service associated with a particular"]
- #[doc = " flight stream. This allows a client of a flight service to upload a stream"]
- #[doc = " of data. Depending on the particular flight service, a client consumer"]
- #[doc = " could be allowed to upload a single stream per descriptor or an unlimited"]
- #[doc = " number. In the latter, the service might implement a 'seal' action that"]
- #[doc = " can be applied to a descriptor once all streams are uploaded."]
+ ///
+ /// Push a stream to the flight service associated with a particular
+ /// flight stream. This allows a client of a flight service to upload a stream
+ /// of data. Depending on the particular flight service, a client consumer
+ /// could be allowed to upload a single stream per descriptor or an unlimited
+ /// number. In the latter, the service might implement a 'seal' action that
+ /// can be applied to a descriptor once all streams are uploaded.
async fn do_put(
&self,
request: tonic::Request<tonic::Streaming<super::FlightData>>,
) -> Result<tonic::Response<Self::DoPutStream>, tonic::Status>;
- #[doc = "Server streaming response type for the DoExchange method."]
- type DoExchangeStream: futures_core::Stream<Item = Result<super::FlightData, tonic::Status>>
+ ///Server streaming response type for the DoExchange method.
+ type DoExchangeStream: futures_core::Stream<
+ Item = Result<super::FlightData, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " Open a bidirectional data channel for a given descriptor. This"]
- #[doc = " allows clients to send and receive arbitrary Arrow data and"]
- #[doc = " application-specific metadata in a single logical stream. In"]
- #[doc = " contrast to DoGet/DoPut, this is more suited for clients"]
- #[doc = " offloading computation (rather than storage) to a Flight service."]
+ ///
+ /// Open a bidirectional data channel for a given descriptor. This
+ /// allows clients to send and receive arbitrary Arrow data and
+ /// application-specific metadata in a single logical stream. In
+ /// contrast to DoGet/DoPut, this is more suited for clients
+ /// offloading computation (rather than storage) to a Flight service.
async fn do_exchange(
&self,
request: tonic::Request<tonic::Streaming<super::FlightData>>,
) -> Result<tonic::Response<Self::DoExchangeStream>, tonic::Status>;
- #[doc = "Server streaming response type for the DoAction method."]
- type DoActionStream: futures_core::Stream<Item = Result<super::Result, tonic::Status>>
+ ///Server streaming response type for the DoAction method.
+ type DoActionStream: futures_core::Stream<
+ Item = Result<super::Result, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " Flight services can support an arbitrary number of simple actions in"]
- #[doc = " addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut"]
- #[doc = " operations that are potentially available. DoAction allows a flight client"]
- #[doc = " to do a specific action against a flight service. An action includes"]
- #[doc = " opaque request and response objects that are specific to the type action"]
- #[doc = " being undertaken."]
+ ///
+ /// Flight services can support an arbitrary number of simple actions in
+ /// addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
+ /// operations that are potentially available. DoAction allows a flight client
+ /// to do a specific action against a flight service. An action includes
+ /// opaque request and response objects that are specific to the type action
+ /// being undertaken.
async fn do_action(
&self,
request: tonic::Request<super::Action>,
) -> Result<tonic::Response<Self::DoActionStream>, tonic::Status>;
- #[doc = "Server streaming response type for the ListActions method."]
- type ListActionsStream: futures_core::Stream<Item = Result<super::ActionType, tonic::Status>>
+ ///Server streaming response type for the ListActions method.
+ type ListActionsStream: futures_core::Stream<
+ Item = Result<super::ActionType, tonic::Status>,
+ >
+ Send
+ 'static;
- #[doc = ""]
- #[doc = " A flight service exposes all of the available action types that it has"]
- #[doc = " along with descriptions. This allows different flight consumers to"]
- #[doc = " understand the capabilities of the flight service."]
+ ///
+ /// A flight service exposes all of the available action types that it has
+ /// along with descriptions. This allows different flight consumers to
+ /// understand the capabilities of the flight service.
async fn list_actions(
&self,
request: tonic::Request<super::Empty>,
) -> Result<tonic::Response<Self::ListActionsStream>, tonic::Status>;
}
- #[doc = ""]
- #[doc = " A flight service is an endpoint for retrieving or storing Arrow data. A"]
- #[doc = " flight service can expose one or more predefined endpoints that can be"]
- #[doc = " accessed using the Arrow Flight Protocol. Additionally, a flight service"]
- #[doc = " can expose a set of actions that are available."]
+ ///
+ /// A flight service is an endpoint for retrieving or storing Arrow data. A
+ /// flight service can expose one or more predefined endpoints that can be
+ /// 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: FlightService> {
inner: _Inner<T>,
@@ -646,7 +677,9 @@ pub mod flight_service_server {
struct _Inner<T>(Arc<T>);
impl<T: FlightService> FlightServiceServer<T> {
pub fn new(inner: T) -> Self {
- let inner = Arc::new(inner);
+ Self::from_arc(Arc::new(inner))
+ }
+ pub fn from_arc(inner: Arc<T>) -> Self {
let inner = _Inner(inner);
Self {
inner,
@@ -671,9 +704,12 @@ pub mod flight_service_server {
B::Error: Into<StdError> + Send + 'static,
{
type Response = http::Response<tonic::body::BoxBody>;
- type Error = Never;
+ type Error = std::convert::Infallible;
type Future = BoxFuture<Self::Response, Self::Error>;
- fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+ fn poll_ready(
+ &mut self,
+ _cx: &mut Context<'_>,
+ ) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: http::Request<B>) -> Self::Future {
@@ -682,10 +718,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/Handshake" => {
#[allow(non_camel_case_types)]
struct HandshakeSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::StreamingService<super::HandshakeRequest>
- for HandshakeSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::StreamingService<super::HandshakeRequest>
+ for HandshakeSvc<T> {
type Response = super::HandshakeResponse;
type ResponseStream = T::HandshakeStream;
type Future = BoxFuture<
@@ -723,10 +759,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/ListFlights" => {
#[allow(non_camel_case_types)]
struct ListFlightsSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::ServerStreamingService<super::Criteria>
- for ListFlightsSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::ServerStreamingService<super::Criteria>
+ for ListFlightsSvc<T> {
type Response = super::FlightInfo;
type ResponseStream = T::ListFlightsStream;
type Future = BoxFuture<
@@ -738,7 +774,9 @@ pub mod flight_service_server {
request: tonic::Request<super::Criteria>,
) -> Self::Future {
let inner = self.0.clone();
- let fut = async move { (*inner).list_flights(request).await };
+ let fut = async move {
+ (*inner).list_flights(request).await
+ };
Box::pin(fut)
}
}
@@ -762,20 +800,23 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/GetFlightInfo" => {
#[allow(non_camel_case_types)]
struct GetFlightInfoSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::UnaryService<super::FlightDescriptor>
- for GetFlightInfoSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::UnaryService<super::FlightDescriptor>
+ for GetFlightInfoSvc<T> {
type Response = super::FlightInfo;
- type Future =
- BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+ type Future = BoxFuture<
+ tonic::Response<Self::Response>,
+ tonic::Status,
+ >;
fn call(
&mut self,
request: tonic::Request<super::FlightDescriptor>,
) -> Self::Future {
let inner = self.0.clone();
- let fut =
- async move { (*inner).get_flight_info(request).await };
+ let fut = async move {
+ (*inner).get_flight_info(request).await
+ };
Box::pin(fut)
}
}
@@ -799,13 +840,15 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/GetSchema" => {
#[allow(non_camel_case_types)]
struct GetSchemaSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::UnaryService<super::FlightDescriptor>
- for GetSchemaSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::UnaryService<super::FlightDescriptor>
+ for GetSchemaSvc<T> {
type Response = super::SchemaResult;
- type Future =
- BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+ type Future = BoxFuture<
+ tonic::Response<Self::Response>,
+ tonic::Status,
+ >;
fn call(
&mut self,
request: tonic::Request<super::FlightDescriptor>,
@@ -835,10 +878,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/DoGet" => {
#[allow(non_camel_case_types)]
struct DoGetSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::ServerStreamingService<super::Ticket>
- for DoGetSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::ServerStreamingService<super::Ticket>
+ for DoGetSvc<T> {
type Response = super::FlightData;
type ResponseStream = T::DoGetStream;
type Future = BoxFuture<
@@ -874,10 +917,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/DoPut" => {
#[allow(non_camel_case_types)]
struct DoPutSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::StreamingService<super::FlightData>
- for DoPutSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::StreamingService<super::FlightData>
+ for DoPutSvc<T> {
type Response = super::PutResult;
type ResponseStream = T::DoPutStream;
type Future = BoxFuture<
@@ -913,10 +956,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/DoExchange" => {
#[allow(non_camel_case_types)]
struct DoExchangeSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::StreamingService<super::FlightData>
- for DoExchangeSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::StreamingService<super::FlightData>
+ for DoExchangeSvc<T> {
type Response = super::FlightData;
type ResponseStream = T::DoExchangeStream;
type Future = BoxFuture<
@@ -952,10 +995,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/DoAction" => {
#[allow(non_camel_case_types)]
struct DoActionSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::ServerStreamingService<super::Action>
- for DoActionSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::ServerStreamingService<super::Action>
+ for DoActionSvc<T> {
type Response = super::Result;
type ResponseStream = T::DoActionStream;
type Future = BoxFuture<
@@ -991,10 +1034,10 @@ pub mod flight_service_server {
"/arrow.flight.protocol.FlightService/ListActions" => {
#[allow(non_camel_case_types)]
struct ListActionsSvc<T: FlightService>(pub Arc<T>);
- impl<T: FlightService>
- tonic::server::ServerStreamingService<super::Empty>
- for ListActionsSvc<T>
- {
+ impl<
+ T: FlightService,
+ > tonic::server::ServerStreamingService<super::Empty>
+ for ListActionsSvc<T> {
type Response = super::ActionType;
type ResponseStream = T::ListActionsStream;
type Future = BoxFuture<
@@ -1006,7 +1049,9 @@ pub mod flight_service_server {
request: tonic::Request<super::Empty>,
) -> Self::Future {
let inner = self.0.clone();
- let fut = async move { (*inner).list_actions(request).await };
+ let fut = async move {
+ (*inner).list_actions(request).await
+ };
Box::pin(fut)
}
}
@@ -1027,14 +1072,18 @@ pub mod flight_service_server {
};
Box::pin(fut)
}
- _ => Box::pin(async move {
- Ok(http::Response::builder()
- .status(200)
- .header("grpc-status", "12")
- .header("content-type", "application/grpc")
- .body(empty_body())
- .unwrap())
- }),
+ _ => {
+ Box::pin(async move {
+ Ok(
+ http::Response::builder()
+ .status(200)
+ .header("grpc-status", "12")
+ .header("content-type", "application/grpc")
+ .body(empty_body())
+ .unwrap(),
+ )
+ })
+ }
}
}
}
diff --git a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
index 3acb6e248..ea378a0a2 100644
--- a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
+++ b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
@@ -31,14 +31,14 @@ pub struct CommandGetSqlInfo {
/// Initially, Flight SQL will support the following information types:
/// - Server Information - Range [0-500)
/// - Syntax Information - Range [500-1000)
- /// Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options).
+ /// Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options).
/// Custom options should start at 10,000.
///
/// If omitted, then all metadata will be retrieved.
/// Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
/// at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
/// If additional metadata is included, the metadata IDs should start from 10,000.
- #[prost(uint32, repeated, tag = "1")]
+ #[prost(uint32, repeated, tag="1")]
pub info: ::prost::alloc::vec::Vec<u32>,
}
///
@@ -54,7 +54,8 @@ pub struct CommandGetSqlInfo {
/// >
/// The returned data should be ordered by catalog_name.
#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CommandGetCatalogs {}
+pub struct CommandGetCatalogs {
+}
///
/// Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
/// The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
@@ -74,7 +75,7 @@ pub struct CommandGetDbSchemas {
/// Specifies the Catalog to search for the tables.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "1")]
+ #[prost(string, optional, tag="1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies a filter pattern for schemas to search for.
@@ -82,7 +83,7 @@ pub struct CommandGetDbSchemas {
/// In the pattern string, two special characters can be used to denote matching rules:
/// - "%" means to match any substring with 0 or more characters.
/// - "_" means to match any one character.
- #[prost(string, optional, tag = "2")]
+ #[prost(string, optional, tag="2")]
pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
}
///
@@ -107,7 +108,7 @@ pub struct CommandGetTables {
/// Specifies the Catalog to search for the tables.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "1")]
+ #[prost(string, optional, tag="1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies a filter pattern for schemas to search for.
@@ -115,7 +116,7 @@ pub struct CommandGetTables {
/// In the pattern string, two special characters can be used to denote matching rules:
/// - "%" means to match any substring with 0 or more characters.
/// - "_" means to match any one character.
- #[prost(string, optional, tag = "2")]
+ #[prost(string, optional, tag="2")]
pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies a filter pattern for tables to search for.
@@ -123,16 +124,16 @@ pub struct CommandGetTables {
/// In the pattern string, two special characters can be used to denote matching rules:
/// - "%" means to match any substring with 0 or more characters.
/// - "_" means to match any one character.
- #[prost(string, optional, tag = "3")]
+ #[prost(string, optional, tag="3")]
pub table_name_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies a filter of table types which must match.
/// The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
/// TABLE, VIEW, and SYSTEM TABLE are commonly supported.
- #[prost(string, repeated, tag = "4")]
+ #[prost(string, repeated, tag="4")]
pub table_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Specifies if the Arrow schema should be returned for found tables.
- #[prost(bool, tag = "5")]
+ #[prost(bool, tag="5")]
pub include_schema: bool,
}
///
@@ -149,7 +150,8 @@ pub struct CommandGetTables {
/// >
/// The returned data should be ordered by table_type.
#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CommandGetTableTypes {}
+pub struct CommandGetTableTypes {
+}
///
/// Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
/// Used in the command member of FlightDescriptor for the following RPC calls:
@@ -172,16 +174,16 @@ pub struct CommandGetPrimaryKeys {
/// Specifies the catalog to search for the table.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "1")]
+ #[prost(string, optional, tag="1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies the schema to search for the table.
/// An empty string retrieves those without a schema.
/// If omitted the schema name should not be used to narrow the search.
- #[prost(string, optional, tag = "2")]
+ #[prost(string, optional, tag="2")]
pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
/// Specifies the table to get the primary keys for.
- #[prost(string, tag = "3")]
+ #[prost(string, tag="3")]
pub table: ::prost::alloc::string::String,
}
///
@@ -215,16 +217,16 @@ pub struct CommandGetExportedKeys {
/// Specifies the catalog to search for the foreign key table.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "1")]
+ #[prost(string, optional, tag="1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies the schema to search for the foreign key table.
/// An empty string retrieves those without a schema.
/// If omitted the schema name should not be used to narrow the search.
- #[prost(string, optional, tag = "2")]
+ #[prost(string, optional, tag="2")]
pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
/// Specifies the foreign key table to get the foreign keys for.
- #[prost(string, tag = "3")]
+ #[prost(string, tag="3")]
pub table: ::prost::alloc::string::String,
}
///
@@ -262,16 +264,16 @@ pub struct CommandGetImportedKeys {
/// Specifies the catalog to search for the primary key table.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "1")]
+ #[prost(string, optional, tag="1")]
pub catalog: ::core::option::Option<::prost::alloc::string::String>,
///
/// Specifies the schema to search for the primary key table.
/// An empty string retrieves those without a schema.
/// If omitted the schema name should not be used to narrow the search.
- #[prost(string, optional, tag = "2")]
+ #[prost(string, optional, tag="2")]
pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
/// Specifies the primary key table to get the foreign keys for.
- #[prost(string, tag = "3")]
+ #[prost(string, tag="3")]
pub table: ::prost::alloc::string::String,
}
///
@@ -311,33 +313,33 @@ pub struct CommandGetCrossReference {
/// The catalog name where the parent table is.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "1")]
+ #[prost(string, optional, tag="1")]
pub pk_catalog: ::core::option::Option<::prost::alloc::string::String>,
///*
/// The Schema name where the parent table is.
/// An empty string retrieves those without a schema.
/// If omitted the schema name should not be used to narrow the search.
- #[prost(string, optional, tag = "2")]
+ #[prost(string, optional, tag="2")]
pub pk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
///*
/// The parent table name. It cannot be null.
- #[prost(string, tag = "3")]
+ #[prost(string, tag="3")]
pub pk_table: ::prost::alloc::string::String,
///*
/// The catalog name where the foreign table is.
/// An empty string retrieves those without a catalog.
/// If omitted the catalog name should not be used to narrow the search.
- #[prost(string, optional, tag = "4")]
+ #[prost(string, optional, tag="4")]
pub fk_catalog: ::core::option::Option<::prost::alloc::string::String>,
///*
/// The schema name where the foreign table is.
/// An empty string retrieves those without a schema.
/// If omitted the schema name should not be used to narrow the search.
- #[prost(string, optional, tag = "5")]
+ #[prost(string, optional, tag="5")]
pub fk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
///*
/// The foreign table name. It cannot be null.
- #[prost(string, tag = "6")]
+ #[prost(string, tag="6")]
pub fk_table: ::prost::alloc::string::String,
}
// SQL Execution Action Messages
@@ -347,7 +349,7 @@ pub struct CommandGetCrossReference {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionCreatePreparedStatementRequest {
/// The valid SQL string to create a prepared statement for.
- #[prost(string, tag = "1")]
+ #[prost(string, tag="1")]
pub query: ::prost::alloc::string::String,
}
///
@@ -359,15 +361,15 @@ pub struct ActionCreatePreparedStatementRequest {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionCreatePreparedStatementResult {
/// Opaque handle for the prepared statement on the server.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
- /// If a result set generating query was provided, dataset_schema contains the
+ /// If a result set generating query was provided, dataset_schema contains the
/// schema of the dataset as described in Schema.fbs::Schema, it is serialized as an IPC message.
- #[prost(bytes = "vec", tag = "2")]
+ #[prost(bytes="vec", tag="2")]
pub dataset_schema: ::prost::alloc::vec::Vec<u8>,
- /// If the query provided contained parameters, parameter_schema contains the
+ /// If the query provided contained parameters, parameter_schema contains the
/// schema of the expected parameters as described in Schema.fbs::Schema, it is serialized as an IPC message.
- #[prost(bytes = "vec", tag = "3")]
+ #[prost(bytes="vec", tag="3")]
pub parameter_schema: ::prost::alloc::vec::Vec<u8>,
}
///
@@ -376,7 +378,7 @@ pub struct ActionCreatePreparedStatementResult {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActionClosePreparedStatementRequest {
/// Opaque handle for the prepared statement on the server.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
}
// SQL Execution Messages.
@@ -389,7 +391,7 @@ pub struct ActionClosePreparedStatementRequest {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandStatementQuery {
/// The SQL syntax.
- #[prost(string, tag = "1")]
+ #[prost(string, tag="1")]
pub query: ::prost::alloc::string::String,
}
///*
@@ -398,7 +400,7 @@ pub struct CommandStatementQuery {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TicketStatementQuery {
/// Unique identifier for the instance of the statement to execute.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub statement_handle: ::prost::alloc::vec::Vec<u8>,
}
///
@@ -409,7 +411,7 @@ pub struct TicketStatementQuery {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandPreparedStatementQuery {
/// Opaque handle for the prepared statement on the server.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
}
///
@@ -418,44 +420,43 @@ pub struct CommandPreparedStatementQuery {
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandStatementUpdate {
/// The SQL syntax.
- #[prost(string, tag = "1")]
+ #[prost(string, tag="1")]
pub query: ::prost::alloc::string::String,
}
///
/// Represents a SQL update query. Used in the command member of FlightDescriptor
-/// for the the RPC call DoPut to cause the server to execute the included
+/// for the the RPC call DoPut to cause the server to execute the included
/// prepared statement handle as an update.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommandPreparedStatementUpdate {
/// Opaque handle for the prepared statement on the server.
- #[prost(bytes = "vec", tag = "1")]
+ #[prost(bytes="vec", tag="1")]
pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
}
///
/// Returned from the RPC call DoPut when a CommandStatementUpdate
/// CommandPreparedStatementUpdate was in the request, containing
-/// results from the update.
+/// results from the update.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DoPutUpdateResult {
- /// The number of records updated. A return value of -1 represents
+ /// The number of records updated. A return value of -1 represents
/// an unknown updated record count.
- #[prost(int64, tag = "1")]
+ #[prost(int64, tag="1")]
pub record_count: i64,
}
/// Options for CommandGetSqlInfo.
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlInfo {
// Server Information [0-500): Provides basic information about the Flight SQL Server.
+
/// Retrieves a UTF-8 string with the name of the Flight SQL Server.
FlightSqlServerName = 0,
/// Retrieves a UTF-8 string with the native version of the Flight SQL Server.
FlightSqlServerVersion = 1,
/// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
FlightSqlServerArrowVersion = 2,
- ///
+ ///
/// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
///
/// Returns:
@@ -463,6 +464,7 @@ pub enum SqlInfo {
/// - true: if read only
FlightSqlServerReadOnly = 3,
// SQL Syntax Information [500-1000): provides information about SQL syntax supported by the Flight SQL Server.
+
///
/// Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
///
@@ -1001,9 +1003,7 @@ pub enum SqlInfo {
/// - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
SqlStoredFunctionsUsingCallSyntaxSupported = 576,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedCaseSensitivity {
SqlCaseSensitivityUnknown = 0,
@@ -1011,9 +1011,7 @@ pub enum SqlSupportedCaseSensitivity {
SqlCaseSensitivityUppercase = 2,
SqlCaseSensitivityLowercase = 3,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlNullOrdering {
SqlNullsSortedHigh = 0,
@@ -1021,61 +1019,47 @@ pub enum SqlNullOrdering {
SqlNullsSortedAtStart = 2,
SqlNullsSortedAtEnd = 3,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SupportedSqlGrammar {
SqlMinimumGrammar = 0,
SqlCoreGrammar = 1,
SqlExtendedGrammar = 2,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SupportedAnsi92SqlGrammarLevel {
Ansi92EntrySql = 0,
Ansi92IntermediateSql = 1,
Ansi92FullSql = 2,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlOuterJoinsSupportLevel {
SqlJoinsUnsupported = 0,
SqlLimitedOuterJoins = 1,
SqlFullOuterJoins = 2,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedGroupBy {
SqlGroupByUnrelated = 0,
SqlGroupByBeyondSelect = 1,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedElementActions {
SqlElementInProcedureCalls = 0,
SqlElementInIndexDefinitions = 1,
SqlElementInPrivilegeDefinitions = 2,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedPositionedCommands {
SqlPositionedDelete = 0,
SqlPositionedUpdate = 1,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedSubqueries {
SqlSubqueriesInComparisons = 0,
@@ -1083,17 +1067,13 @@ pub enum SqlSupportedSubqueries {
SqlSubqueriesInIns = 2,
SqlSubqueriesInQuantifieds = 3,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedUnions {
SqlUnion = 0,
SqlUnionAll = 1,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlTransactionIsolationLevel {
SqlTransactionNone = 0,
@@ -1102,18 +1082,14 @@ pub enum SqlTransactionIsolationLevel {
SqlTransactionRepeatableRead = 3,
SqlTransactionSerializable = 4,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedTransactions {
SqlTransactionUnspecified = 0,
SqlDataDefinitionTransactions = 1,
SqlDataManipulationTransactions = 2,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedResultSetType {
SqlResultSetTypeUnspecified = 0,
@@ -1121,18 +1097,14 @@ pub enum SqlSupportedResultSetType {
SqlResultSetTypeScrollInsensitive = 2,
SqlResultSetTypeScrollSensitive = 3,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportedResultSetConcurrency {
SqlResultSetConcurrencyUnspecified = 0,
SqlResultSetConcurrencyReadOnly = 1,
SqlResultSetConcurrencyUpdatable = 2,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SqlSupportsConvert {
SqlConvertBigint = 0,
@@ -1156,9 +1128,7 @@ pub enum SqlSupportsConvert {
SqlConvertVarbinary = 18,
SqlConvertVarchar = 19,
}
-#[derive(
- Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum UpdateDeleteRules {
Cascade = 0,
diff --git a/integration-testing/Cargo.toml b/integration-testing/Cargo.toml
index 7947016f4..27c4b4ec1 100644
--- a/integration-testing/Cargo.toml
+++ b/integration-testing/Cargo.toml
@@ -37,10 +37,10 @@ async-trait = "0.1.41"
clap = { version = "3", features = ["derive", "env"] }
futures = "0.3"
hex = "0.4"
-prost = "0.9"
+prost = "0.10"
serde = { version = "1.0", features = ["rc"] }
serde_derive = "1.0"
serde_json = { version = "1.0", features = ["preserve_order"] }
tokio = { version = "1.0", features = ["macros", "rt", "rt-multi-thread"] }
-tonic = "0.6"
+tonic = "0.7"
tracing-subscriber = { version = "0.3.1", optional = true }