icepick 0.4.1

Experimental Rust client for Apache Iceberg with WASM support for AWS S3 Tables and Cloudflare R2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Namespace commands

use crate::cli::catalog::CatalogConfig;
use crate::cli::output::{print, OutputFormat, Outputable};
use crate::spec::NamespaceIdent;
use clap::Subcommand;
use serde::Serialize;
use std::collections::HashMap;

/// Namespace commands
#[derive(Debug, Subcommand)]
pub enum NamespaceCommand {
    /// List all namespaces (not supported by all catalogs)
    List,

    /// Create a namespace
    Create {
        /// Namespace name
        name: String,
    },
}

/// Namespace list output
#[derive(Debug, Serialize)]
pub struct NamespaceList {
    pub namespaces: Vec<String>,
}

impl Outputable for NamespaceList {
    fn to_text(&self) -> String {
        if self.namespaces.is_empty() {
            return "No namespaces found.".to_string();
        }

        let mut lines = vec!["Namespaces:".to_string()];
        for ns in &self.namespaces {
            lines.push(format!("  {}", ns));
        }
        lines.join("\n")
    }
}

/// Namespace create result
#[derive(Debug, Serialize)]
pub struct NamespaceCreateResult {
    pub namespace: String,
    pub created: bool,
}

impl Outputable for NamespaceCreateResult {
    fn to_text(&self) -> String {
        if self.created {
            format!("Namespace '{}' created successfully.", self.namespace)
        } else {
            format!("Namespace '{}' already exists.", self.namespace)
        }
    }
}

/// Execute a namespace command
pub async fn execute(
    command: NamespaceCommand,
    config: &CatalogConfig,
    format: OutputFormat,
) -> Result<(), String> {
    let catalog = config.create_catalog().await?;

    match command {
        NamespaceCommand::List => {
            let namespaces = catalog
                .list_namespaces()
                .await
                .map_err(|e| format!("Failed to list namespaces: {}", e))?;

            let result = NamespaceList {
                namespaces: namespaces.iter().map(|ns| ns.to_string()).collect(),
            };
            print(&result, format);
            Ok(())
        }

        NamespaceCommand::Create { name } => {
            let namespace = NamespaceIdent::new(vec![name.clone()]);

            // Check if namespace already exists
            let exists = catalog
                .namespace_exists(&namespace)
                .await
                .map_err(|e| format!("Failed to check namespace: {}", e))?;

            if !exists {
                catalog
                    .create_namespace(&namespace, HashMap::new())
                    .await
                    .map_err(|e| format!("Failed to create namespace: {}", e))?;
            }

            let result = NamespaceCreateResult {
                namespace: name,
                created: !exists,
            };
            print(&result, format);
            Ok(())
        }
    }
}