Method execute_read_only

graphlite/src/catalog/providers/schema.rs:685–747

(&self, op: CatalogOperation)

    }

    fn execute_read_only(&self, op: CatalogOperation) -> CatalogResult<CatalogResponse> {
        // Handle read-only operations by delegating to the main execute method
        // Since SchemaCatalog operations don't mutate during queries, this is safe
        match op {
            CatalogOperation::Query { query_type, params } => {
                match query_type {
                    QueryType::List => {
                        let schemas: Vec<_> = self.schemas.values().collect();
                        let results = serde_json::to_value(schemas)?;
                        Ok(CatalogResponse::Query { results })
                    }
                    QueryType::Get => {
                        let schema_name =
                            params.get("name").and_then(|v| v.as_str()).ok_or_else(|| {
                                CatalogError::InvalidParameters("Schema name required".to_string())
                            })?;

                        if let Some(schema) = self.schemas.get(schema_name) {
                            let results = serde_json::to_value(schema)?;
                            Ok(CatalogResponse::Query { results })
                        } else {
                            Err(CatalogError::EntityNotFound(format!(
                                "Schema '{}' not found",
                                schema_name
                            )))
                        }
                    }
                    QueryType::GetDefault => {
                        if let Some(default_name) = &self.default_schema {
                            if let Some(schema) = self.schemas.get(default_name) {
                                let results = serde_json::to_value(schema)?;
                                Ok(CatalogResponse::Query { results })
                            } else {
                                Err(CatalogError::EntityNotFound(
                                    "Default schema not found".to_string(),
                                ))
                            }
                        } else {
                            Err(CatalogError::EntityNotFound(
                                "No default schema set".to_string(),
                            ))
                        }
                    }
                    QueryType::Exists => {
                        let schema_name =
                            params.get("name").and_then(|v| v.as_str()).ok_or_else(|| {
                                CatalogError::InvalidParameters("Schema name required".to_string())
                            })?;

                        let exists = self.schemas.contains_key(schema_name);
                        Ok(CatalogResponse::Query {
                            results: serde_json::to_value(exists)?,
                        })
                    }
                    // Handle all other QueryType variants with NotSupported
                    _ => Ok(CatalogResponse::NotSupported),
                }
            }