Struct RowRequestBuilder

pub struct RowRequestBuilder { /* private fields */ }

Builder for constructing table row queries

Provides a fluent interface for building queries with filtering, sorting, and other options.

Examples

Basic query with filters, sorting, and view selection:

use baserow_rs::{ConfigBuilder, Baserow, BaserowTableOperations, OrderDirection, filter::Filter};
use baserow_rs::api::client::BaserowClient;

#[tokio::main]
async fn main() {
    let config = ConfigBuilder::new()
        .base_url("https://api.baserow.io")
        .api_key("your-api-key")
        .build();

    let baserow = Baserow::with_configuration(config);
    let table = baserow.table_by_id(1234);

    // Build a query with filters, sorting, and view selection
    let results = table.rows()
        .view(456)  // Query from a specific view
        .filter_by("Status", Filter::Equal, "Active")
        .order_by("Created", OrderDirection::Desc)
        .get()
        .await
        .unwrap();

    println!("Found {} matching rows", results.count);
}

Paginated query:

// Get first page of 25 rows
let page1 = table.clone().rows()
    .page_size(25)
    .offset(0)
    .get()
    .await
    .unwrap();

// Get second page
let page2 = table.clone().rows()
    .page_size(25)
    .offset(25)
    .get()
    .await
    .unwrap();

println!("Total rows: {}", page1.count);
println!("First page rows: {}", page1.results.len());
println!("Second page rows: {}", page2.results.len());

Implementations

impl RowRequestBuilder

pub fn view(self, id: i32) -> Self

Set the view ID to query rows from a specific view

Arguments

• id - The ID of the view to query

Example

table.rows()
    .view(123);

pub fn page_size(self, size: i32) -> Self

Set the number of rows to return per page

Arguments

• size - The number of rows to return per page

Example

table.rows()
    .page_size(25);

pub fn offset(self, offset: i32) -> Self

Set the offset for pagination

Arguments

• offset - The number of rows to skip

Example

table.rows()
    .offset(50);

pub fn with_table(self, table: BaserowTable) -> Self

pub fn with_baserow(self, baserow: Baserow) -> Self

pub fn order_by(self, field: &str, direction: OrderDirection) -> Self

Add sorting criteria to the query

Arguments

• field - The field name to sort by
• direction - The sort direction (Asc or Desc)

Example

table.rows()
    .order_by("Created", OrderDirection::Desc);

pub fn filter_by(self, field: &str, filter_op: Filter, value: &str) -> Self

Add a filter condition to the query

Arguments

• field - The field name to filter on
• filter_op - The filter operation (Equal, Contains, etc.)
• value - The value to filter against

Example

table.rows()
    .filter_by("Status", Filter::Equal, "Active");

pub async fn get(self) -> Result<RowsResponse, Box<dyn Error>>

Execute the query and return the results

Sends the constructed query to Baserow and returns the matching rows along with pagination information.

Returns

A RowsResponse containing the matching rows and metadata

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn get_typed<T>(self) -> Result<TypedRowsResponse<T>, Box<dyn Error>>

where T: DeserializeOwned,

Execute the query and return typed results

Similar to get(), but deserializes the rows into the specified type.

Type Parameters

• T - The type to deserialize each row into. Must implement DeserializeOwned.

Returns

A TypedRowsResponse containing the matching rows deserialized as type T

Errors

Returns an error if the request fails or the response cannot be parsed