code fmt and schema discovery doc

genezhang · genezhang · commit c10242ef0387 · 2026-04-03T16:32:57.000-07:00
diff --git a/clickgraph-embedded/src/database.rs b/clickgraph-embedded/src/database.rs
@@ -163,14 +163,20 @@ impl Database {
         let view_count = clickgraph::executor::data_loader::load_schema_sources(&executor, &schema)
             .map_err(|e| EmbeddedError::Executor(e.to_string()))?;
         if view_count > 0 {
-            log::info!("Created {} chdb VIEW(s) from schema source: entries", view_count);
+            log::info!(
+                "Created {} chdb VIEW(s) from schema source: entries",
+                view_count
+            );
         }
 
         let table_count =
             clickgraph::executor::data_loader::create_writable_tables(&executor, &schema)
                 .map_err(|e| EmbeddedError::Executor(e.to_string()))?;
         if table_count > 0 {
-            log::info!("Created {} writable ReplacingMergeTree table(s)", table_count);
+            log::info!(
+                "Created {} writable ReplacingMergeTree table(s)",
+                table_count
+            );
         }
 
         let remote_executor = Self::build_remote_executor(&runtime, config.remote.as_ref())?;
@@ -194,8 +200,9 @@ impl Database {
         let graph_schema = load_graph_schema(schema_path.as_ref())?;
         let runtime = build_runtime()?;
         let remote_executor =
-            Self::build_remote_executor(&runtime, Some(&remote))?
-                .ok_or_else(|| EmbeddedError::Executor("Failed to connect to remote ClickHouse".to_string()))?;
+            Self::build_remote_executor(&runtime, Some(&remote))?.ok_or_else(|| {
+                EmbeddedError::Executor("Failed to connect to remote ClickHouse".to_string())
+            })?;
         Ok(Database {
             executor: Arc::new(NullExecutor),
             remote_executor: Some(remote_executor),
@@ -223,7 +230,9 @@ impl Database {
             ))
             .map_err(EmbeddedError::Executor)?;
         log::info!("Remote ClickHouse executor initialized: {}", remote.url);
-        Ok(Some(Arc::new(RemoteClickHouseExecutor::new(Arc::new(pool))) as Arc<dyn QueryExecutor>))
+        Ok(Some(
+            Arc::new(RemoteClickHouseExecutor::new(Arc::new(pool))) as Arc<dyn QueryExecutor>,
+        ))
     }
 
     /// Return a reference to the graph schema.
diff --git a/clickgraph-embedded/src/lib.rs b/clickgraph-embedded/src/lib.rs
@@ -48,9 +48,9 @@ pub(crate) mod write_helpers;
 
 pub use connection::Connection;
 pub use cypher_loader::LoadStats;
-pub use database::{Database, RemoteConfig, SystemConfig};
 #[cfg(feature = "embedded")]
 pub use database::StorageCredentials;
+pub use database::{Database, RemoteConfig, SystemConfig};
 pub use error::EmbeddedError;
 pub use export::{ExportFormat, ExportOptions};
 pub use graph_result::{GraphEdge, GraphNode, GraphResult, GraphResultBuilder, StoreStats};
diff --git a/clickgraph-tool/src/commands/nl.rs b/clickgraph-tool/src/commands/nl.rs
@@ -30,7 +30,10 @@ pub async fn run_nl(description: &str, execute: bool, format: &str, cfg: &CgConf
         "No schema loaded. Generate a general Cypher query.".to_string()
     };
 
-    let user_prompt = format!("{}\n\nNatural language query: {}", schema_context, description);
+    let user_prompt = format!(
+        "{}\n\nNatural language query: {}",
+        schema_context, description
+    );
 
     eprintln!("Calling {} ({})...", llm.model, provider_name(&llm));
     let response = llm.call(NL_SYSTEM_PROMPT, &user_prompt).await?;
diff --git a/clickgraph-tool/src/commands/query.rs b/clickgraph-tool/src/commands/query.rs
@@ -87,17 +87,33 @@ fn print_table(cols: &[String], rows: &[Vec<Value>]) {
         }
     }
 
-    let sep: String = widths.iter().map(|w| "-".repeat(w + 2)).collect::<Vec<_>>().join("+");
+    let sep: String = widths
+        .iter()
+        .map(|w| "-".repeat(w + 2))
+        .collect::<Vec<_>>()
+        .join("+");
     println!("+{}+", sep);
-    let header: Vec<String> = cols.iter().zip(&widths).map(|(c, w)| format!(" {:w$} ", c, w = w)).collect();
+    let header: Vec<String> = cols
+        .iter()
+        .zip(&widths)
+        .map(|(c, w)| format!(" {:w$} ", c, w = w))
+        .collect();
     println!("|{}|", header.join("|"));
     println!("+{}+", sep);
     for row in rows {
-        let cells: Vec<String> = row.iter().zip(&widths).map(|(v, w)| format!(" {:w$} ", value_str(v), w = w)).collect();
+        let cells: Vec<String> = row
+            .iter()
+            .zip(&widths)
+            .map(|(v, w)| format!(" {:w$} ", value_str(v), w = w))
+            .collect();
         println!("|{}|", cells.join("|"));
     }
     println!("+{}+", sep);
-    println!("({} row{})", rows.len(), if rows.len() == 1 { "" } else { "s" });
+    println!(
+        "({} row{})",
+        rows.len(),
+        if rows.len() == 1 { "" } else { "s" }
+    );
 }
 
 fn print_json(cols: &[String], rows: &[Vec<Value>]) -> Result<()> {
diff --git a/clickgraph-tool/src/commands/schema.rs b/clickgraph-tool/src/commands/schema.rs
@@ -1,10 +1,6 @@
 use anyhow::{anyhow, Result};
-use clickgraph::{
-    graph_catalog::{
-        config::GraphSchemaConfig,
-        llm_prompt,
-        schema_discovery::SchemaDiscovery,
-    },
+use clickgraph::graph_catalog::{
+    config::GraphSchemaConfig, llm_prompt, schema_discovery::SchemaDiscovery,
 };
 
 use crate::{
@@ -133,10 +129,18 @@ pub fn run_diff(old_path: &str, new_path: &str) -> Result<()> {
     let new_cfg = GraphSchemaConfig::from_yaml_file(new_path)
         .map_err(|e| anyhow!("Failed to load '{}': {}", new_path, e))?;
 
-    let old_nodes: std::collections::BTreeSet<String> =
-        old_cfg.graph_schema.nodes.iter().map(|n| n.label.clone()).collect();
-    let new_nodes: std::collections::BTreeSet<String> =
-        new_cfg.graph_schema.nodes.iter().map(|n| n.label.clone()).collect();
+    let old_nodes: std::collections::BTreeSet<String> = old_cfg
+        .graph_schema
+        .nodes
+        .iter()
+        .map(|n| n.label.clone())
+        .collect();
+    let new_nodes: std::collections::BTreeSet<String> = new_cfg
+        .graph_schema
+        .nodes
+        .iter()
+        .map(|n| n.label.clone())
+        .collect();
 
     let old_rels: std::collections::BTreeSet<String> = old_cfg
         .graph_schema
@@ -174,8 +178,16 @@ pub fn run_diff(old_path: &str, new_path: &str) -> Result<()> {
 
     // Property-level diff for nodes present in both
     for label in old_nodes.intersection(&new_nodes) {
-        let old_node = old_cfg.graph_schema.nodes.iter().find(|n| &n.label == label);
-        let new_node = new_cfg.graph_schema.nodes.iter().find(|n| &n.label == label);
+        let old_node = old_cfg
+            .graph_schema
+            .nodes
+            .iter()
+            .find(|n| &n.label == label);
+        let new_node = new_cfg
+            .graph_schema
+            .nodes
+            .iter()
+            .find(|n| &n.label == label);
         if let (Some(old), Some(new)) = (old_node, new_node) {
             let old_props: std::collections::BTreeSet<String> =
                 old.properties.keys().cloned().collect();
@@ -208,7 +220,10 @@ fn merge_batch_yaml(base: &str, continuation: &str) -> String {
     let mut result = base.trim_end().to_string();
 
     if !cont_nodes.is_empty() {
-        if let Some(pos) = result.find("\n  edges:").or_else(|| result.find("\nedges:")) {
+        if let Some(pos) = result
+            .find("\n  edges:")
+            .or_else(|| result.find("\nedges:"))
+        {
             result.insert_str(pos, &format!("\n{}", cont_nodes));
         } else {
             result.push('\n');
diff --git a/clickgraph-tool/src/config.rs b/clickgraph-tool/src/config.rs
@@ -68,9 +68,7 @@ impl CgConfig {
         let file_cfg = load_file_config();
 
         // Schema path: CLI flag > env (already handled by clap) > config file
-        let schema_path = schema
-            .clone()
-            .or_else(|| file_cfg.schema.path.clone());
+        let schema_path = schema.clone().or_else(|| file_cfg.schema.path.clone());
 
         // ClickHouse URL: CLI flag > env > config file
         let clickhouse_url = clickhouse
@@ -81,7 +79,11 @@ impl CgConfig {
         let ch_user = if ch_user != "default" {
             ch_user.to_string()
         } else {
-            file_cfg.clickhouse.user.clone().unwrap_or_else(|| "default".to_string())
+            file_cfg
+                .clickhouse
+                .user
+                .clone()
+                .unwrap_or_else(|| "default".to_string())
         };
 
         let ch_password = if !ch_password.is_empty() {
@@ -129,9 +131,11 @@ impl CgConfig {
 
     /// Resolve the schema path, returning an error if not set
     pub fn require_schema(&self) -> Result<&str> {
-        self.schema_path
-            .as_deref()
-            .ok_or_else(|| anyhow::anyhow!("No schema file specified. Use --schema <file> or set CG_SCHEMA env var."))
+        self.schema_path.as_deref().ok_or_else(|| {
+            anyhow::anyhow!(
+                "No schema file specified. Use --schema <file> or set CG_SCHEMA env var."
+            )
+        })
     }
 }
 
diff --git a/clickgraph-tool/src/llm.rs b/clickgraph-tool/src/llm.rs
@@ -64,7 +64,9 @@ impl LlmClient {
                     .api_key
                     .clone()
                     .or_else(|| std::env::var("ANTHROPIC_API_KEY").ok())
-                    .ok_or_else(|| anyhow!("No API key found. Set CG_LLM_API_KEY or ANTHROPIC_API_KEY."))?;
+                    .ok_or_else(|| {
+                        anyhow!("No API key found. Set CG_LLM_API_KEY or ANTHROPIC_API_KEY.")
+                    })?;
                 (
                     LlmProvider::Anthropic,
                     key,
@@ -78,11 +80,16 @@ impl LlmClient {
         let api_url = cfg.base_url.clone().unwrap_or(default_url);
         let max_tokens = cfg.max_tokens.unwrap_or(8192);
 
-        let client = Client::builder()
-            .timeout(LLM_REQUEST_TIMEOUT)
-            .build()?;
+        let client = Client::builder().timeout(LLM_REQUEST_TIMEOUT).build()?;
 
-        Ok(LlmClient { api_key, model, api_url, max_tokens, provider, client })
+        Ok(LlmClient {
+            api_key,
+            model,
+            api_url,
+            max_tokens,
+            provider,
+            client,
+        })
     }
 
     /// Call the LLM with a system prompt and user message, return the text response.
@@ -119,10 +126,14 @@ impl LlmClient {
             model: &self.model,
             max_tokens: self.max_tokens,
             system: system_prompt,
-            messages: vec![Msg { role: "user", content: user_prompt }],
+            messages: vec![Msg {
+                role: "user",
+                content: user_prompt,
+            }],
         };
 
-        let resp = self.client
+        let resp = self
+            .client
             .post(&self.api_url)
             .header("x-api-key", &self.api_key)
             .header("anthropic-version", "2023-06-01")
@@ -172,12 +183,19 @@ impl LlmClient {
             model: &self.model,
             max_tokens: self.max_tokens,
             messages: vec![
-                Msg { role: "system", content: system_prompt },
-                Msg { role: "user", content: user_prompt },
+                Msg {
+                    role: "system",
+                    content: system_prompt,
+                },
+                Msg {
+                    role: "user",
+                    content: user_prompt,
+                },
             ],
         };
 
-        let resp = self.client
+        let resp = self
+            .client
             .post(&self.api_url)
             .bearer_auth(&self.api_key)
             .json(&body)
diff --git a/clickgraph-tool/src/main.rs b/clickgraph-tool/src/main.rs
@@ -24,11 +24,21 @@ struct Cli {
     clickhouse: Option<String>,
 
     /// ClickHouse user
-    #[arg(long, env = "CG_CLICKHOUSE_USER", global = true, default_value = "default")]
+    #[arg(
+        long,
+        env = "CG_CLICKHOUSE_USER",
+        global = true,
+        default_value = "default"
+    )]
     ch_user: String,
 
     /// ClickHouse password
-    #[arg(long, env = "CG_CLICKHOUSE_PASSWORD", global = true, default_value = "")]
+    #[arg(
+        long,
+        env = "CG_CLICKHOUSE_PASSWORD",
+        global = true,
+        default_value = ""
+    )]
     ch_password: String,
 
     /// ClickHouse database to query
@@ -139,7 +149,13 @@ enum SchemaCommands {
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
-    let cfg = CgConfig::load(&cli.schema, &cli.clickhouse, &cli.ch_user, &cli.ch_password, &cli.ch_database)?;
+    let cfg = CgConfig::load(
+        &cli.schema,
+        &cli.clickhouse,
+        &cli.ch_user,
+        &cli.ch_password,
+        &cli.ch_database,
+    )?;
 
     match cli.command {
         Commands::Sql { query } => {
@@ -150,11 +166,19 @@ async fn main() -> Result<()> {
             commands::query::run_validate(&query, &cfg)?;
         }
 
-        Commands::Query { query, sql_only, format } => {
+        Commands::Query {
+            query,
+            sql_only,
+            format,
+        } => {
             commands::query::run_query(&query, sql_only, &format, &cfg).await?;
         }
 
-        Commands::Nl { description, execute, format } => {
+        Commands::Nl {
+            description,
+            execute,
+            format,
+        } => {
             commands::nl::run_nl(&description, execute, &format, &cfg).await?;
         }
 
@@ -163,16 +187,34 @@ async fn main() -> Result<()> {
                 commands::schema::run_show(&format, &cfg)?;
             }
             SchemaCommands::Validate { file } => {
-                let path = file
-                    .or_else(|| cfg.schema_path.clone())
-                    .ok_or_else(|| anyhow::anyhow!("No schema file specified. Use --schema or provide a file argument."))?;
+                let path = file.or_else(|| cfg.schema_path.clone()).ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "No schema file specified. Use --schema or provide a file argument."
+                    )
+                })?;
                 commands::schema::run_validate_schema(&path)?;
             }
-            SchemaCommands::Discover { database, clickhouse, user, password, out } => {
+            SchemaCommands::Discover {
+                database,
+                clickhouse,
+                user,
+                password,
+                out,
+            } => {
                 let ch_url = clickhouse
                     .or_else(|| cfg.clickhouse_url.clone())
-                    .ok_or_else(|| anyhow::anyhow!("No ClickHouse URL. Use --clickhouse or CG_CLICKHOUSE_URL."))?;
-                commands::schema::run_discover(&database, &ch_url, &user, &password, out.as_deref(), &cfg).await?;
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("No ClickHouse URL. Use --clickhouse or CG_CLICKHOUSE_URL.")
+                    })?;
+                commands::schema::run_discover(
+                    &database,
+                    &ch_url,
+                    &user,
+                    &password,
+                    out.as_deref(),
+                    &cfg,
+                )
+                .await?;
             }
             SchemaCommands::Diff { old, new } => {
                 commands::schema::run_diff(&old, &new)?;
diff --git a/clickgraph-tool/src/schema_fmt.rs b/clickgraph-tool/src/schema_fmt.rs
diff --git a/docs/wiki/Schema-Discovery.md b/docs/wiki/Schema-Discovery.md
