Struct Query

pub struct Query {
    pub logical_name: &'static str,
    pub limit: Option<u32>,
    pub filter: Option<Filter>,
    pub order: Option<Vec<Order>>,
}

Represents a Microsoft Dataverse query

These queries are modeled after the ODATAv4 specifications used by Microsoft Dataverse. This section is prone to change as these specifications allow for a wide array of possible querying options.

Examples

use uuid::Uuid;
use serde::Deserialize;
use powerplatform_dataverse_service_client::{
    client::{Client, Page},
    entity::ReadEntity,
    result::Result,
    select::Select,
    query::{
        attribute::Attribute,
        filter::Filter,
        order::Order,
        Query
    }
};

async fn test() -> Result<()> {
    let query = Query::new("contacts")
        .limit(3)
        .filter(Filter::Equal("firstname", Attribute::String(String::from("Testy"))))
        .order(vec![Order::Ascending("lastname")]);

    let client = Client::new_dummy();
    let contacts: Page<Contact> = client.retrieve_multiple(&query).await?;
    Ok(())
}

#[derive(Deserialize)]
struct Contact {
    contactid: Uuid,
    firstname: String,
    lastname: String,
}

impl ReadEntity for Contact {}

impl Select for Contact {
    fn get_columns() -> &'static [&'static str] {
        &["contactid", "firstname", "lastname"]
    }
}

Fields

logical_name: &'static str

limit: Option<u32>

filter: Option<Filter>

order: Option<Vec<Order>>

Implementations

impl Query

pub fn new(logical_name: &'static str) -> Self

Creates a new empty query for the given table

Please note that though it is possible to execute this empty query directly, this will attempt to retrieve every single entity record from the table.

Use the limit(...) and filter(...) functions to add a limiting factor to your query of you don’t want this

pub fn limit(self, count: u32) -> Self

limits the query result to at most n entities

pub fn filter(self, filter: Filter) -> Self

filters the query result to records that match the predicate defined in the given filter

pub fn order(self, order: Vec<Order>) -> Self

orders the query result by the given attributes and directions

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Query

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

Formats the value using the given formatter.

impl Display for Query

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

Formats the value using the given formatter.