#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(clippy::redundant_clone)]
pub mod models;
#[derive(Clone)]
pub struct Client {
endpoint: String,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
pipeline: azure_core::Pipeline,
}
#[derive(Clone)]
pub struct ClientBuilder {
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
endpoint: Option<String>,
scopes: Option<Vec<String>>,
options: azure_core::ClientOptions,
}
pub const DEFAULT_ENDPOINT: &str = azure_core::resource_manager_endpoint::AZURE_PUBLIC_CLOUD;
impl ClientBuilder {
#[doc = "Create a new instance of `ClientBuilder`."]
#[must_use]
pub fn new(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> Self {
Self {
credential,
endpoint: None,
scopes: None,
options: azure_core::ClientOptions::default(),
}
}
#[doc = "Set the endpoint."]
#[must_use]
pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
self.endpoint = Some(endpoint.into());
self
}
#[doc = "Set the scopes."]
#[must_use]
pub fn scopes(mut self, scopes: &[&str]) -> Self {
self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect());
self
}
#[doc = "Set the retry options."]
#[must_use]
pub fn retry(mut self, retry: impl Into<azure_core::RetryOptions>) -> Self {
self.options = self.options.retry(retry);
self
}
#[doc = "Set the transport options."]
#[must_use]
pub fn transport(mut self, transport: impl Into<azure_core::TransportOptions>) -> Self {
self.options = self.options.transport(transport);
self
}
#[doc = "Convert the builder into a `Client` instance."]
#[must_use]
pub fn build(self) -> Client {
let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
let scopes = self.scopes.unwrap_or_else(|| vec![format!("{}/", endpoint)]);
Client::new(endpoint, self.credential, scopes, self.options)
}
}
impl Client {
pub(crate) fn endpoint(&self) -> &str {
self.endpoint.as_str()
}
pub(crate) fn token_credential(&self) -> &dyn azure_core::auth::TokenCredential {
self.credential.as_ref()
}
pub(crate) fn scopes(&self) -> Vec<&str> {
self.scopes.iter().map(String::as_str).collect()
}
pub(crate) async fn send(&self, request: &mut azure_core::Request) -> azure_core::Result<azure_core::Response> {
let mut context = azure_core::Context::default();
self.pipeline.send(&mut context, request).await
}
#[doc = "Create a new `ClientBuilder`."]
#[must_use]
pub fn builder(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> ClientBuilder {
ClientBuilder::new(credential)
}
#[doc = "Create a new `Client`."]
#[must_use]
pub fn new(
endpoint: impl Into<String>,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
options: azure_core::ClientOptions,
) -> Self {
let endpoint = endpoint.into();
let pipeline = azure_core::Pipeline::new(
option_env!("CARGO_PKG_NAME"),
option_env!("CARGO_PKG_VERSION"),
options,
Vec::new(),
Vec::new(),
);
Self {
endpoint,
credential,
scopes,
pipeline,
}
}
pub fn catalog_client(&self) -> catalog::Client {
catalog::Client(self.clone())
}
}
pub mod catalog {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Grants an access control list (ACL) entry to the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `parameters`: Parameters supplied to create or update an access control list (ACL) entry for a Data Lake Analytics catalog."]
pub fn grant_acl(&self, parameters: impl Into<models::AclCreateOrUpdateParameters>) -> grant_acl::RequestBuilder {
grant_acl::RequestBuilder {
client: self.0.clone(),
parameters: parameters.into(),
}
}
#[doc = "Grants an access control list (ACL) entry to the database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database."]
#[doc = "* `parameters`: Parameters supplied to create or update an access control list (ACL) entry for a database."]
pub fn grant_acl_to_database(
&self,
database_name: impl Into<String>,
parameters: impl Into<models::AclCreateOrUpdateParameters>,
) -> grant_acl_to_database::RequestBuilder {
grant_acl_to_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Revokes an access control list (ACL) entry from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `parameters`: Parameters supplied to delete an access control list (ACL) entry from a Data Lake Analytics catalog."]
pub fn revoke_acl(&self, parameters: impl Into<models::AclDeleteParameters>) -> revoke_acl::RequestBuilder {
revoke_acl::RequestBuilder {
client: self.0.clone(),
parameters: parameters.into(),
}
}
#[doc = "Revokes an access control list (ACL) entry for the database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database."]
#[doc = "* `parameters`: Parameters supplied to delete an access control list (ACL) entry for a database."]
pub fn revoke_acl_from_database(
&self,
database_name: impl Into<String>,
parameters: impl Into<models::AclDeleteParameters>,
) -> revoke_acl_from_database::RequestBuilder {
revoke_acl_from_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Gets the specified secret in the specified database. This is deprecated and will be removed in the next release. Please use GetCredential instead."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the secret."]
#[doc = "* `secret_name`: The name of the secret to get"]
pub fn get_secret(&self, database_name: impl Into<String>, secret_name: impl Into<String>) -> get_secret::RequestBuilder {
get_secret::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
secret_name: secret_name.into(),
}
}
#[doc = "Creates the specified secret for use with external data sources in the specified database. This is deprecated and will be removed in the next release. Please use CreateCredential instead."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database in which to create the secret."]
#[doc = "* `secret_name`: The name of the secret."]
#[doc = "* `parameters`: The parameters required to create the secret (name and password)"]
pub fn create_secret(
&self,
database_name: impl Into<String>,
secret_name: impl Into<String>,
parameters: impl Into<models::DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters>,
) -> create_secret::RequestBuilder {
create_secret::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
secret_name: secret_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Modifies the specified secret for use with external data sources in the specified database. This is deprecated and will be removed in the next release. Please use UpdateCredential instead."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the secret."]
#[doc = "* `secret_name`: The name of the secret."]
#[doc = "* `parameters`: The parameters required to modify the secret (name and password)"]
pub fn update_secret(
&self,
database_name: impl Into<String>,
secret_name: impl Into<String>,
parameters: impl Into<models::DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters>,
) -> update_secret::RequestBuilder {
update_secret::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
secret_name: secret_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Deletes the specified secret in the specified database. This is deprecated and will be removed in the next release. Please use DeleteCredential instead."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the secret."]
#[doc = "* `secret_name`: The name of the secret to delete"]
pub fn delete_secret(&self, database_name: impl Into<String>, secret_name: impl Into<String>) -> delete_secret::RequestBuilder {
delete_secret::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
secret_name: secret_name.into(),
}
}
#[doc = "Deletes all secrets in the specified database. This is deprecated and will be removed in the next release. In the future, please only drop individual credentials using DeleteCredential"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the secret."]
pub fn delete_all_secrets(&self, database_name: impl Into<String>) -> delete_all_secrets::RequestBuilder {
delete_all_secrets::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
}
}
#[doc = "Retrieves the specified credential from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the schema."]
#[doc = "* `credential_name`: The name of the credential."]
pub fn get_credential(
&self,
database_name: impl Into<String>,
credential_name: impl Into<String>,
) -> get_credential::RequestBuilder {
get_credential::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
credential_name: credential_name.into(),
}
}
#[doc = "Deletes the specified credential in the specified database"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the credential."]
#[doc = "* `credential_name`: The name of the credential to delete"]
pub fn delete_credential(
&self,
database_name: impl Into<String>,
credential_name: impl Into<String>,
) -> delete_credential::RequestBuilder {
delete_credential::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
credential_name: credential_name.into(),
parameters: None,
cascade: None,
}
}
#[doc = "Creates the specified credential for use with external data sources in the specified database."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database in which to create the credential. Note: This is NOT an external database name, but the name of an existing U-SQL database that should contain the new credential object."]
#[doc = "* `credential_name`: The name of the credential."]
#[doc = "* `parameters`: The parameters required to create the credential (name and password)"]
pub fn create_credential(
&self,
database_name: impl Into<String>,
credential_name: impl Into<String>,
parameters: impl Into<models::DataLakeAnalyticsCatalogCredentialCreateParameters>,
) -> create_credential::RequestBuilder {
create_credential::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
credential_name: credential_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Modifies the specified credential for use with external data sources in the specified database"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the credential."]
#[doc = "* `credential_name`: The name of the credential."]
#[doc = "* `parameters`: The parameters required to modify the credential (name and password)"]
pub fn update_credential(
&self,
database_name: impl Into<String>,
credential_name: impl Into<String>,
parameters: impl Into<models::DataLakeAnalyticsCatalogCredentialUpdateParameters>,
) -> update_credential::RequestBuilder {
update_credential::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
credential_name: credential_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Retrieves the list of credentials from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the schema."]
pub fn list_credentials(&self, database_name: impl Into<String>) -> list_credentials::RequestBuilder {
list_credentials::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified external data source from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the external data source."]
#[doc = "* `external_data_source_name`: The name of the external data source."]
pub fn get_external_data_source(
&self,
database_name: impl Into<String>,
external_data_source_name: impl Into<String>,
) -> get_external_data_source::RequestBuilder {
get_external_data_source::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
external_data_source_name: external_data_source_name.into(),
}
}
#[doc = "Retrieves the list of external data sources from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the external data sources."]
pub fn list_external_data_sources(&self, database_name: impl Into<String>) -> list_external_data_sources::RequestBuilder {
list_external_data_sources::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified procedure from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the procedure."]
#[doc = "* `schema_name`: The name of the schema containing the procedure."]
#[doc = "* `procedure_name`: The name of the procedure."]
pub fn get_procedure(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
procedure_name: impl Into<String>,
) -> get_procedure::RequestBuilder {
get_procedure::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
procedure_name: procedure_name.into(),
}
}
#[doc = "Retrieves the list of procedures from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the procedures."]
#[doc = "* `schema_name`: The name of the schema containing the procedures."]
pub fn list_procedures(&self, database_name: impl Into<String>, schema_name: impl Into<String>) -> list_procedures::RequestBuilder {
list_procedures::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified table from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table."]
#[doc = "* `schema_name`: The name of the schema containing the table."]
#[doc = "* `table_name`: The name of the table."]
pub fn get_table(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
) -> get_table::RequestBuilder {
get_table::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
}
}
#[doc = "Retrieves the list of table fragments from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table fragments."]
#[doc = "* `schema_name`: The name of the schema containing the table fragments."]
#[doc = "* `table_name`: The name of the table containing the table fragments."]
pub fn list_table_fragments(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
) -> list_table_fragments::RequestBuilder {
list_table_fragments::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of tables from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the tables."]
#[doc = "* `schema_name`: The name of the schema containing the tables."]
pub fn list_tables(&self, database_name: impl Into<String>, schema_name: impl Into<String>) -> list_tables::RequestBuilder {
list_tables::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
basic: None,
}
}
#[doc = "Retrieves the list of all table statistics within the specified schema from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the statistics."]
#[doc = "* `schema_name`: The name of the schema containing the statistics."]
pub fn list_table_statistics_by_database_and_schema(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
) -> list_table_statistics_by_database_and_schema::RequestBuilder {
list_table_statistics_by_database_and_schema::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified table type from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table type."]
#[doc = "* `schema_name`: The name of the schema containing the table type."]
#[doc = "* `table_type_name`: The name of the table type to retrieve."]
pub fn get_table_type(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_type_name: impl Into<String>,
) -> get_table_type::RequestBuilder {
get_table_type::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_type_name: table_type_name.into(),
}
}
#[doc = "Retrieves the list of table types from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table types."]
#[doc = "* `schema_name`: The name of the schema containing the table types."]
pub fn list_table_types(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
) -> list_table_types::RequestBuilder {
list_table_types::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified package from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the package."]
#[doc = "* `schema_name`: The name of the schema containing the package."]
#[doc = "* `package_name`: The name of the package."]
pub fn get_package(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
package_name: impl Into<String>,
) -> get_package::RequestBuilder {
get_package::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
package_name: package_name.into(),
}
}
#[doc = "Retrieves the list of packages from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the packages."]
#[doc = "* `schema_name`: The name of the schema containing the packages."]
pub fn list_packages(&self, database_name: impl Into<String>, schema_name: impl Into<String>) -> list_packages::RequestBuilder {
list_packages::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified view from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the view."]
#[doc = "* `schema_name`: The name of the schema containing the view."]
#[doc = "* `view_name`: The name of the view."]
pub fn get_view(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
view_name: impl Into<String>,
) -> get_view::RequestBuilder {
get_view::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
view_name: view_name.into(),
}
}
#[doc = "Retrieves the list of views from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the views."]
#[doc = "* `schema_name`: The name of the schema containing the views."]
pub fn list_views(&self, database_name: impl Into<String>, schema_name: impl Into<String>) -> list_views::RequestBuilder {
list_views::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified table statistics from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the statistics."]
#[doc = "* `schema_name`: The name of the schema containing the statistics."]
#[doc = "* `table_name`: The name of the table containing the statistics."]
#[doc = "* `statistics_name`: The name of the table statistics."]
pub fn get_table_statistic(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
statistics_name: impl Into<String>,
) -> get_table_statistic::RequestBuilder {
get_table_statistic::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
statistics_name: statistics_name.into(),
}
}
#[doc = "Retrieves the list of table statistics from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the statistics."]
#[doc = "* `schema_name`: The name of the schema containing the statistics."]
#[doc = "* `table_name`: The name of the table containing the statistics."]
pub fn list_table_statistics(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
) -> list_table_statistics::RequestBuilder {
list_table_statistics::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves a preview set of rows in given partition."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the partition."]
#[doc = "* `schema_name`: The name of the schema containing the partition."]
#[doc = "* `table_name`: The name of the table containing the partition."]
#[doc = "* `partition_name`: The name of the table partition."]
pub fn preview_table_partition(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
partition_name: impl Into<String>,
) -> preview_table_partition::RequestBuilder {
preview_table_partition::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
partition_name: partition_name.into(),
max_rows: None,
max_columns: None,
}
}
#[doc = "Retrieves the specified table partition from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the partition."]
#[doc = "* `schema_name`: The name of the schema containing the partition."]
#[doc = "* `table_name`: The name of the table containing the partition."]
#[doc = "* `partition_name`: The name of the table partition."]
pub fn get_table_partition(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
partition_name: impl Into<String>,
) -> get_table_partition::RequestBuilder {
get_table_partition::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
partition_name: partition_name.into(),
}
}
#[doc = "Retrieves a preview set of rows in given table."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table."]
#[doc = "* `schema_name`: The name of the schema containing the table."]
#[doc = "* `table_name`: The name of the table."]
pub fn preview_table(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
) -> preview_table::RequestBuilder {
preview_table::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
max_rows: None,
max_columns: None,
}
}
#[doc = "Retrieves the list of table partitions from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the partitions."]
#[doc = "* `schema_name`: The name of the schema containing the partitions."]
#[doc = "* `table_name`: The name of the table containing the partitions."]
pub fn list_table_partitions(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_name: impl Into<String>,
) -> list_table_partitions::RequestBuilder {
list_table_partitions::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_name: table_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of types within the specified database and schema from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the types."]
#[doc = "* `schema_name`: The name of the schema containing the types."]
pub fn list_types(&self, database_name: impl Into<String>, schema_name: impl Into<String>) -> list_types::RequestBuilder {
list_types::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified table valued function from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table valued function."]
#[doc = "* `schema_name`: The name of the schema containing the table valued function."]
#[doc = "* `table_valued_function_name`: The name of the tableValuedFunction."]
pub fn get_table_valued_function(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
table_valued_function_name: impl Into<String>,
) -> get_table_valued_function::RequestBuilder {
get_table_valued_function::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
table_valued_function_name: table_valued_function_name.into(),
}
}
#[doc = "Retrieves the list of table valued functions from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table valued functions."]
#[doc = "* `schema_name`: The name of the schema containing the table valued functions."]
pub fn list_table_valued_functions(
&self,
database_name: impl Into<String>,
schema_name: impl Into<String>,
) -> list_table_valued_functions::RequestBuilder {
list_table_valued_functions::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified assembly from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the assembly."]
#[doc = "* `assembly_name`: The name of the assembly."]
pub fn get_assembly(&self, database_name: impl Into<String>, assembly_name: impl Into<String>) -> get_assembly::RequestBuilder {
get_assembly::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
assembly_name: assembly_name.into(),
}
}
#[doc = "Retrieves the list of assemblies from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the assembly."]
pub fn list_assemblies(&self, database_name: impl Into<String>) -> list_assemblies::RequestBuilder {
list_assemblies::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified schema from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the schema."]
#[doc = "* `schema_name`: The name of the schema."]
pub fn get_schema(&self, database_name: impl Into<String>, schema_name: impl Into<String>) -> get_schema::RequestBuilder {
get_schema::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
schema_name: schema_name.into(),
}
}
#[doc = "Retrieves the list of schemas from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the schema."]
pub fn list_schemas(&self, database_name: impl Into<String>) -> list_schemas::RequestBuilder {
list_schemas::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of all statistics in a database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table statistics."]
pub fn list_table_statistics_by_database(
&self,
database_name: impl Into<String>,
) -> list_table_statistics_by_database::RequestBuilder {
list_table_statistics_by_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of all tables in a database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the tables."]
pub fn list_tables_by_database(&self, database_name: impl Into<String>) -> list_tables_by_database::RequestBuilder {
list_tables_by_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
basic: None,
}
}
#[doc = "Retrieves the list of all table valued functions in a database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the table valued functions."]
pub fn list_table_valued_functions_by_database(
&self,
database_name: impl Into<String>,
) -> list_table_valued_functions_by_database::RequestBuilder {
list_table_valued_functions_by_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of all views in a database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database containing the views."]
pub fn list_views_by_database(&self, database_name: impl Into<String>) -> list_views_by_database::RequestBuilder {
list_views_by_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of access control list (ACL) entries for the database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database."]
pub fn list_acls_by_database(&self, database_name: impl Into<String>) -> list_acls_by_database::RequestBuilder {
list_acls_by_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the list of access control list (ACL) entries for the Data Lake Analytics catalog."]
pub fn list_acls(&self) -> list_acls::RequestBuilder {
list_acls::RequestBuilder {
client: self.0.clone(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
#[doc = "Retrieves the specified database from the Data Lake Analytics catalog."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `database_name`: The name of the database."]
pub fn get_database(&self, database_name: impl Into<String>) -> get_database::RequestBuilder {
get_database::RequestBuilder {
client: self.0.clone(),
database_name: database_name.into(),
}
}
#[doc = "Retrieves the list of databases from the Data Lake Analytics catalog."]
pub fn list_databases(&self) -> list_databases::RequestBuilder {
list_databases::RequestBuilder {
client: self.0.clone(),
filter: None,
top: None,
skip: None,
select: None,
orderby: None,
count: None,
}
}
}
pub mod grant_acl {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) parameters: models::AclCreateOrUpdateParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!("{}/catalog/usql/acl?op=GRANTACE", this.client.endpoint(),))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod grant_acl_to_database {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) parameters: models::AclCreateOrUpdateParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/acl?op=GRANTACE",
this.client.endpoint(),
&this.database_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod revoke_acl {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) parameters: models::AclDeleteParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!("{}/catalog/usql/acl?op=REVOKEACE", this.client.endpoint(),))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod revoke_acl_from_database {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) parameters: models::AclDeleteParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/acl?op=REVOKEACE",
this.client.endpoint(),
&this.database_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_secret {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlSecret> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlSecret = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) secret_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/secrets/{}",
this.client.endpoint(),
&this.database_name,
&this.secret_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlSecret>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_secret {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) secret_name: String,
pub(crate) parameters: models::DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/secrets/{}",
this.client.endpoint(),
&this.database_name,
&this.secret_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod update_secret {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) secret_name: String,
pub(crate) parameters: models::DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/secrets/{}",
this.client.endpoint(),
&this.database_name,
&this.secret_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod delete_secret {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) secret_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/secrets/{}",
this.client.endpoint(),
&this.database_name,
&this.secret_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod delete_all_secrets {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/secrets",
this.client.endpoint(),
&this.database_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_credential {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlCredential> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlCredential = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) credential_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/credentials/{}",
this.client.endpoint(),
&this.database_name,
&this.credential_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlCredential>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_credential {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) credential_name: String,
pub(crate) parameters: Option<models::DataLakeAnalyticsCatalogCredentialDeleteParameters>,
pub(crate) cascade: Option<bool>,
}
impl RequestBuilder {
#[doc = "The parameters to delete a credential if the current user is not the account owner."]
pub fn parameters(mut self, parameters: impl Into<models::DataLakeAnalyticsCatalogCredentialDeleteParameters>) -> Self {
self.parameters = Some(parameters.into());
self
}
#[doc = "Indicates if the delete should be a cascading delete (which deletes all resources dependent on the credential as well as the credential) or not. If false will fail if there are any resources relying on the credential."]
pub fn cascade(mut self, cascade: bool) -> Self {
self.cascade = Some(cascade);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/credentials/{}",
this.client.endpoint(),
&this.database_name,
&this.credential_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = if let Some(parameters) = &this.parameters {
req.insert_header("content-type", "application/json");
azure_core::to_json(parameters)?
} else {
azure_core::EMPTY_BODY
};
if let Some(cascade) = &this.cascade {
req.url_mut().query_pairs_mut().append_pair("cascade", &cascade.to_string());
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_credential {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) credential_name: String,
pub(crate) parameters: models::DataLakeAnalyticsCatalogCredentialCreateParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/credentials/{}",
this.client.endpoint(),
&this.database_name,
&this.credential_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod update_credential {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) credential_name: String,
pub(crate) parameters: models::DataLakeAnalyticsCatalogCredentialUpdateParameters,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/credentials/{}",
this.client.endpoint(),
&this.database_name,
&this.credential_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_credentials {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlCredentialList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlCredentialList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlCredentialList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/credentials",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_external_data_source {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlExternalDataSource> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlExternalDataSource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) external_data_source_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/externaldatasources/{}",
this.client.endpoint(),
&this.database_name,
&this.external_data_source_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlExternalDataSource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_external_data_sources {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlExternalDataSourceList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlExternalDataSourceList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlExternalDataSourceList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/externaldatasources",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_procedure {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlProcedure> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlProcedure = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) procedure_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/procedures/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.procedure_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlProcedure>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_procedures {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlProcedureList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlProcedureList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlProcedureList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/procedures",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_table {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTable> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTable = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTable>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_table_fragments {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableFragmentList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableFragmentList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableFragmentList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/tablefragments",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_tables {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
pub(crate) basic: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
#[doc = "The basic switch indicates what level of information to return when listing tables. When basic is true, only database_name, schema_name, table_name and version are returned for each table, otherwise all table metadata is returned. By default, it is false. Optional."]
pub fn basic(mut self, basic: bool) -> Self {
self.basic = Some(basic);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
if let Some(basic) = &this.basic {
req.url_mut().query_pairs_mut().append_pair("basic", &basic.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_table_statistics_by_database_and_schema {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableStatisticsList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableStatisticsList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableStatisticsList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/statistics",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_table_type {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableType> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableType = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_type_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tabletypes/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_type_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTableType>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_table_types {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableTypeList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableTypeList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableTypeList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tabletypes",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_package {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlPackage> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlPackage = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) package_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/packages/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.package_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlPackage>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_packages {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlPackageList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlPackageList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlPackageList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/packages",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_view {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlView> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlView = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) view_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/views/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.view_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlView>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_views {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlViewList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlViewList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlViewList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/views",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_table_statistic {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableStatistics> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableStatistics = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) statistics_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/statistics/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name,
&this.statistics_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTableStatistics>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_table_statistics {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableStatisticsList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableStatisticsList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableStatisticsList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/statistics",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod preview_table_partition {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTablePreview> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTablePreview = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) partition_name: String,
pub(crate) max_rows: Option<i64>,
pub(crate) max_columns: Option<i64>,
}
impl RequestBuilder {
#[doc = "The maximum number of preview rows to be retrieved.Rows returned may be less than or equal to this number depending on row sizes and number of rows in the partition."]
pub fn max_rows(mut self, max_rows: i64) -> Self {
self.max_rows = Some(max_rows);
self
}
#[doc = "The maximum number of columns to be retrieved."]
pub fn max_columns(mut self, max_columns: i64) -> Self {
self.max_columns = Some(max_columns);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions/{}/previewrows",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name,
&this.partition_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(max_rows) = &this.max_rows {
req.url_mut().query_pairs_mut().append_pair("maxRows", &max_rows.to_string());
}
if let Some(max_columns) = &this.max_columns {
req.url_mut().query_pairs_mut().append_pair("maxColumns", &max_columns.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTablePreview>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_table_partition {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTablePartition> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTablePartition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) partition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name,
&this.partition_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTablePartition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod preview_table {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTablePreview> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTablePreview = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) max_rows: Option<i64>,
pub(crate) max_columns: Option<i64>,
}
impl RequestBuilder {
#[doc = "The maximum number of preview rows to be retrieved. Rows returned may be less than or equal to this number depending on row sizes and number of rows in the table."]
pub fn max_rows(mut self, max_rows: i64) -> Self {
self.max_rows = Some(max_rows);
self
}
#[doc = "The maximum number of columns to be retrieved."]
pub fn max_columns(mut self, max_columns: i64) -> Self {
self.max_columns = Some(max_columns);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/previewrows",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(max_rows) = &this.max_rows {
req.url_mut().query_pairs_mut().append_pair("maxRows", &max_rows.to_string());
}
if let Some(max_columns) = &this.max_columns {
req.url_mut().query_pairs_mut().append_pair("maxColumns", &max_columns.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTablePreview>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_table_partitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTablePartitionList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTablePartitionList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTablePartitionList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_types {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTypeList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTypeList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTypeList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/types",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_table_valued_function {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableValuedFunction> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableValuedFunction = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) table_valued_function_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tablevaluedfunctions/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name,
&this.table_valued_function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlTableValuedFunction>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_table_valued_functions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableValuedFunctionList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableValuedFunctionList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableValuedFunctionList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}/tablevaluedfunctions",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_assembly {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlAssembly> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlAssembly = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) assembly_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/assemblies/{}",
this.client.endpoint(),
&this.database_name,
&this.assembly_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlAssembly>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_assemblies {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlAssemblyList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlAssemblyList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlAssemblyList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/assemblies",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_schema {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlSchema> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlSchema = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) schema_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas/{}",
this.client.endpoint(),
&this.database_name,
&this.schema_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlSchema>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_schemas {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlSchemaList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlSchemaList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlSchemaList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/schemas",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_table_statistics_by_database {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableStatisticsList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableStatisticsList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableStatisticsList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/statistics",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_tables_by_database {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
pub(crate) basic: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
#[doc = "The basic switch indicates what level of information to return when listing tables. When basic is true, only database_name, schema_name, table_name and version are returned for each table, otherwise all table metadata is returned. By default, it is false"]
pub fn basic(mut self, basic: bool) -> Self {
self.basic = Some(basic);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/tables",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
if let Some(basic) = &this.basic {
req.url_mut().query_pairs_mut().append_pair("basic", &basic.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_table_valued_functions_by_database {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlTableValuedFunctionList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlTableValuedFunctionList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlTableValuedFunctionList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/tablevaluedfunctions",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_views_by_database {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlViewList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlViewList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlViewList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/views",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_acls_by_database {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AclList> {
let bytes = self.0.into_body().collect().await?;
let body: models::AclList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::AclList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}/acl",
this.client.endpoint(),
&this.database_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_acls {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AclList> {
let bytes = self.0.into_body().collect().await?;
let body: models::AclList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::AclList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!("{}/catalog/usql/acl", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_database {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlDatabase> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlDatabase = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) database_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/catalog/usql/databases/{}",
this.client.endpoint(),
&this.database_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::USqlDatabase>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_databases {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::USqlDatabaseList> {
let bytes = self.0.into_body().collect().await?;
let body: models::USqlDatabaseList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) filter: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) skip: Option<i32>,
pub(crate) select: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) count: Option<bool>,
}
impl RequestBuilder {
#[doc = "OData filter. Optional."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "The number of items to return. Optional."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The number of items to skip over before returning elements. Optional."]
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
#[doc = "OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description. Optional."]
pub fn select(mut self, select: impl Into<String>) -> Self {
self.select = Some(select.into());
self
}
#[doc = "OrderBy clause. One or more comma-separated expressions with an optional \"asc\" (the default) or \"desc\" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc. Optional."]
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
#[doc = "The Boolean value of true or false to request a count of the matching resources included with the resources in the response, e.g. Categories?$count=true. Optional."]
pub fn count(mut self, count: bool) -> Self {
self.count = Some(count);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::USqlDatabaseList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!("{}/catalog/usql/databases", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2016-11-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut().query_pairs_mut().append_pair("$skip", &skip.to_string());
}
if let Some(select) = &this.select {
req.url_mut().query_pairs_mut().append_pair("$select", select);
}
if let Some(orderby) = &this.orderby {
req.url_mut().query_pairs_mut().append_pair("$orderby", orderby);
}
if let Some(count) = &this.count {
req.url_mut().query_pairs_mut().append_pair("$count", &count.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}