Method execute

graphlite/src/catalog/providers/schema.rs:490–634

(&mut self, op: CatalogOperation)

    }

    fn execute(&mut self, op: CatalogOperation) -> CatalogResult<CatalogResponse> {
        match op {
            CatalogOperation::Create {
                entity_type,
                name,
                params,
            } => {
                match entity_type {
                    EntityType::Schema => {
                        // Check if schema already exists and handle IF NOT EXISTS
                        let if_not_exists = params
                            .get("if_not_exists")
                            .and_then(|v| v.as_bool())
                            .unwrap_or(false);

                        if self.schemas.contains_key(&name) {
                            if if_not_exists {
                                // Schema exists but IF NOT EXISTS was specified, so succeed silently
                                Ok(CatalogResponse::Success {
                                    data: Some(
                                        json!({ "message": format!("Schema '{}' already exists", name) }),
                                    ),
                                })
                            } else {
                                // Schema exists and no IF NOT EXISTS, return error
                                Err(CatalogError::DuplicateEntry(format!(
                                    "Schema '{}' already exists",
                                    name
                                )))
                            }
                        } else {
                            // Schema doesn't exist, create it
                            let schema = Schema::from_params(name.clone(), &params);
                            self.add_schema(schema)?;
                            Ok(CatalogResponse::Success {
                                data: Some(
                                    json!({ "message": format!("Schema '{}' created", name) }),
                                ),
                            })
                        }
                    }
                    _ => Ok(CatalogResponse::NotSupported),
                }
            }

            CatalogOperation::Drop {
                entity_type,
                name,
                cascade,
            } => match entity_type {
                EntityType::Schema => {
                    let removed = self.remove_schema(&name, cascade)?;
                    Ok(CatalogResponse::Success {
                        data: Some(serde_json::to_value(removed)?),
                    })
                }
                _ => Ok(CatalogResponse::NotSupported),
            },