Struct SourceQuery 

pub struct SourceQuery {
    pub source_id: String,
    pub query_id: String,
    pub routes: Vec<OperationRoute>,
}

A specification for retrieving and transforming data from a source.

The SourceQuery struct defines where to obtain data and how to transform it before processing. It specifies a data source, an identifier to query within that source, and optionally a series of routing operations to apply to the retrieved value.

This structure is a key component of signal definitions, allowing each signal to combine and transform data from multiple sources.

Examples

use bothan_lib::registry::source::{SourceQuery, OperationRoute, Operation};

// Create a query for BTC/USDT from Binance, converted to USD
let query = SourceQuery::new(
    "binance",
    "btcusdt",
    vec![
        // Convert from USDT to USD using the USDT-USD signal
        OperationRoute::new("USDT-USD", Operation::Multiply),
    ]
);

Fields

source_id: String

The identifier of the data source.

This corresponds to a registered worker that can provide data for this query. Examples might include exchange names like “binance” or “coinbase”.

query_id: String

The query identifier to use within the data source.

This specifies what data to retrieve from the source, such as a trading pair like “btcusdt” or an asset identifier like “bitcoin”.

routes: Vec<OperationRoute>

Routing operations to apply to the retrieved value.

These operations are applied sequentially to transform the source value before it is sent to the processor. If not provided, no transformations will be applied.

Implementations

impl SourceQuery

pub fn new<T, U>(source_id: T, query_id: U, routes: Vec<OperationRoute>) -> Self

where T: Into<String>, U: Into<String>,

Creates a new source query.

This constructor creates a source query that will retrieve data from the specified source and apply the provided routing operations.

Examples

use bothan_lib::registry::source::{SourceQuery, OperationRoute, Operation};

// Create a query for ETH/USD from Coinbase with no transformations
let direct_query = SourceQuery::new("coinbase", "ETH-USD", vec![]);

// Create a query for ETH/BTC from Kraken, converted to USD
let converted_query = SourceQuery::new(
    "kraken",
    "ethbtc",
    vec![
        // Convert from BTC to USD using the BTC-USD signal
        OperationRoute::new("BTC-USD", Operation::Multiply),
    ]
);

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for SourceQuery

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for SourceQuery

fn clone(&self) -> SourceQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SourceQuery

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for SourceQuery

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for SourceQuery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for SourceQuery

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl PartialEq for SourceQuery

fn eq(&self, other: &SourceQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SourceQuery

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SourceQuery