Struct CatalogResource 

pub struct CatalogResource<T> { /* private fields */ }

A selected subtree. Names are unescaped identifiers. Apply replaces the whole definition; it is not a patch. Mutations never retry automatically.

An interrupted or malformed mutation response reports catalog_commit_outcome_unknown. Read the current state before deciding whether to retry. Typed definitions reject unsupported fields; Self::raw preserves them, including arbitrary-precision JSON numbers.

Implementations

impl<T> CatalogResource<T>

pub fn raw(&self) -> CatalogResource<Value>

impl<T: Serialize + DeserializeOwned> CatalogResource<T>

pub async fn get(&self) -> Result<CatalogSnapshot<T>, Error>

Reads the complete definition and its ETag.

Examples found in repository

examples/table.rs (line 28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = common::client()?;
    let table_name = std::env::var("SCOPEDB_TABLE").unwrap_or_else(|_| "events".to_string());
    let table = client
        .table(table_name)
        .with_database(common::database())
        .with_schema(common::schema());

    println!("identifier: {}", table.identifier());

    let description = table.catalog().get().await?.definition;
    for column in description.columns {
        println!("{}: {:?}", column.name, column.data_type);
    }

    Ok(())
}

examples/catalog.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = common::client()?;
    let database = common::database();
    let schema = common::schema();

    let catalog = client.catalog().get().await?;
    for item in catalog.definition.databases {
        println!(
            "database {}: {}",
            item.name,
            item.comment.unwrap_or_default()
        );
    }
    let snapshot = client.catalog().schema(&database, &schema).get().await?;
    println!("schema ETag: {}", snapshot.etag);
    for table in snapshot.definition.tables {
        println!("table {}: {:?}", table.name, table.columns);
    }
    Ok(())
}

pub async fn apply( &self, definition: &T, options: CatalogOptions, ) -> Result<CatalogResult<T>, Error>

Replaces the selected definition, including its children. Omitted fields are cleared. Start from a snapshot to retain fields you are not changing.

Preview with dry_run and use if_match to reject concurrent changes. Set allow_destructive only after reviewing the potential data loss.

use scopedb_client::CatalogOptions;

let resource = client.table("events").catalog();
let snapshot = resource.get().await?;
let mut definition = snapshot.definition;
definition.comment = Some("Application events".to_string());

let preview = resource
    .apply(
        &definition,
        CatalogOptions {
            dry_run: true,
            if_match: Some(snapshot.etag),
            ..Default::default()
        },
    )
    .await?;
println!("destructive = {}", preview.destructive);
resource
    .apply(
        &definition,
        CatalogOptions {
            if_match: Some(preview.etag),
            ..Default::default()
        },
    )
    .await?;

pub async fn delete( &self, options: CatalogOptions, ) -> Result<CatalogResult<T>, Error>

Deletes the selected resource. Use dry_run to preview the change and if_match to require the ETag from a prior read or preview.

Trait Implementations

impl<T: Clone> Clone for CatalogResource<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for CatalogResource<T>

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

Formats the value using the given formatter.