Struct BucketSelect 

pub struct BucketSelect {
    pub metadata: Metadata,
    pub endpoint: Option<String>,
    pub profile: String,
    pub region: Option<String>,
    pub bucket: String,
    pub path: String,
    pub query: String,
    pub parameters: Box<Value>,
    pub limit: Option<usize>,
    pub skip: usize,
    pub timeout: Option<Duration>,
    /* private fields */
}

Fields

metadata: Metadata

endpoint: Option<String>

profile: String

region: Option<String>

bucket: String

path: String

query: String

parameters: Box<Value>

limit: Option<usize>

skip: usize

timeout: Option<Duration>

Trait Implementations

impl Clone for BucketSelect

fn clone(&self) -> BucketSelect

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Connector for BucketSelect

fn set_document(&mut self, document: Box<dyn Document>) -> Result<()>

See Connector::set_document for more details.

fn document(&self) -> Result<&dyn Document>

See Connector::document for more details.

fn set_parameters(&mut self, parameters: Value)

See Connector::set_parameters for more details.

fn metadata(&self) -> Metadata

See Connector::metadata for more details.

fn is_variable(&self) -> bool

See Connector::is_variable for more details.

Example

use chewdata::connector::bucket_select::BucketSelect;
use chewdata::connector::Connector;
use serde_json::Value;

let mut connector = BucketSelect::default();
assert_eq!(false, connector.is_variable());
let params: Value = serde_json::from_str(r#"{"field":"value"}"#).unwrap();
connector.set_parameters(params);
connector.path = "/dir/filename_{{ field }}.ext".to_string();
assert_eq!(true, connector.is_variable());

fn is_resource_will_change(&self, new_parameters: Value) -> Result<bool>

See Connector::is_resource_will_change for more details.

Example

use chewdata::connector::{bucket_select::BucketSelect, Connector};
use serde_json::Value;

let mut connector = BucketSelect::default();
let params = serde_json::from_str(r#"{"field":"test"}"#).unwrap();
assert_eq!(false, connector.is_resource_will_change(Value::Null).unwrap());
connector.path = "/dir/static.ext".to_string();
assert_eq!(false, connector.is_resource_will_change(Value::Null).unwrap());
connector.path = "/dir/dynamic_{{ field }}.ext".to_string();
assert_eq!(true, connector.is_resource_will_change(params).unwrap());

fn path(&self) -> String

See Connector::path for more details.

Examples

use chewdata::connector::bucket_select::BucketSelect;
use chewdata::connector::Connector;
use serde_json::Value;

let mut connector = BucketSelect::default();
connector.path = "/dir/filename_{{ field }}.ext".to_string();
let params: Value = serde_json::from_str(r#"{"field":"value"}"#).unwrap();
connector.set_parameters(params);
assert_eq!("/dir/filename_value.ext", connector.path());

fn len<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

See Connector::len for more details.

Examples

use chewdata::connector::bucket_select::BucketSelect;
use chewdata::connector::Connector;
use chewdata::document::json::Json;
use chewdata::Metadata;
use std::io;

use macro_rules_attribute::apply;
use smol_macros::main;

#[apply(main!)]
async fn main() -> io::Result<()> {
    let document = Json::default();
    let mut connector = BucketSelect::default();
    connector.bucket = "my-bucket".to_string();
    connector.path = "data/one_line.json".to_string();
    connector.query = "select * from s3object".to_string();
    connector.metadata = Metadata {
        ..Json::default().metadata
    };
    connector.set_document(Box::new(document)).unwrap();
    assert!(0 < connector.len().await?, "The length of the document is not greather than 0");
    connector.path = "data/not-found-file".to_string();
    assert_eq!(0, connector.len().await?);

    Ok(())
}

fn fetch<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<DataStream>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

See Connector::fetch for more details.

Examples

use chewdata::connector::{bucket_select::BucketSelect, Connector};
use chewdata::document::json::Json;
use chewdata::Metadata;
use smol::stream::StreamExt;
use std::io;

use macro_rules_attribute::apply;
use smol_macros::main;

#[apply(main!)]
async fn main() -> io::Result<()> {
    let document = Box::new(Json::default());

    let mut connector = BucketSelect::default();
    connector.path = "data/one_line.json".to_string();
    connector.bucket = "my-bucket".to_string();
    connector.query = "select * from s3object".to_string();
    connector.set_document(document);

    let datastream = connector.fetch().await.unwrap().unwrap();
    assert!(
        0 < datastream.count().await,
        "The inner connector should have a size upper than zero"
    );

    Ok(())
}

fn send<'life0, 'life1, 'async_trait>( &'life0 mut self, _dataset: &'life1 DataSet, ) -> Pin<Box<dyn Future<Output = Result<Option<DataStream>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

See Connector::send for more details.

fn erase<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

See Connector::erase for more details.

fn paginate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Box<dyn Connector>>> + Send>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

See Connector::paginate for more details.

fn set_metadata(&mut self, _metadata: Metadata)

Set the connector metadata that can change with the document metadata.

fn is_empty<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Check if the resource is empty.

impl Debug for BucketSelect

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BucketSelect

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BucketSelect

where BucketSelect: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BucketSelect

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.