unitycatalog_server/api/
functions.rs

1use itertools::Itertools;
2
3use unitycatalog_common::models::functions::v1::*;
4use unitycatalog_common::models::{ObjectLabel, ResourceIdent, ResourceName};
5
6use super::{RequestContext, SecuredAction};
7use crate::Result;
8pub use crate::codegen::functions::FunctionHandler;
9use crate::policy::{Permission, Policy, process_resources};
10use crate::store::ResourceStore;
11
12#[async_trait::async_trait]
13impl<T: ResourceStore + Policy<RequestContext>> FunctionHandler<RequestContext> for T {
14    #[tracing::instrument(skip(self, context), fields(resource_name))]
15    async fn list_functions(
16        &self,
17        request: ListFunctionsRequest,
18        context: RequestContext,
19    ) -> Result<ListFunctionsResponse> {
20        self.check_required(&request, &context).await?;
21        let (mut resources, next_page_token) = self
22            .list(
23                &ObjectLabel::Function,
24                Some(&ResourceName::new([
25                    &request.catalog_name,
26                    &request.schema_name,
27                ])),
28                request.max_results.map(|v| v as usize),
29                request.page_token,
30            )
31            .await?;
32        process_resources(self, &context, &Permission::Read, &mut resources).await?;
33        Ok(ListFunctionsResponse {
34            functions: resources.into_iter().map(|r| r.try_into()).try_collect()?,
35            next_page_token,
36            ..Default::default()
37        })
38    }
39
40    #[tracing::instrument(skip(self, context), fields(resource_name))]
41    async fn create_function(
42        &self,
43        request: CreateFunctionRequest,
44        context: RequestContext,
45    ) -> Result<Function> {
46        self.check_required(&request, &context).await?;
47        let function_info = request
48            .function_info
49            .ok_or_else(|| crate::Error::invalid_argument("function_info must be provided"))?;
50        tracing::Span::current().record("resource_name", &function_info.name);
51        let full_name = format!(
52            "{}.{}.{}",
53            function_info.catalog_name, function_info.schema_name, function_info.name
54        );
55        let resource = Function {
56            name: function_info.name,
57            catalog_name: function_info.catalog_name,
58            schema_name: function_info.schema_name,
59            full_name,
60            data_type: function_info.data_type,
61            full_data_type: function_info.full_data_type,
62            input_params: Some(function_info.input_params.into_option().unwrap_or_default()).into(),
63            parameter_style: function_info.parameter_style,
64            is_deterministic: function_info.is_deterministic,
65            sql_data_access: function_info.sql_data_access,
66            is_null_call: function_info.is_null_call,
67            security_type: function_info.security_type,
68            routine_body: function_info.routine_body,
69            routine_definition: function_info.routine_definition,
70            routine_body_language: function_info.routine_body_language,
71            comment: function_info.comment,
72            properties: function_info.properties,
73            ..Default::default()
74        };
75        Ok(self.create(resource.into()).await?.0.try_into()?)
76    }
77
78    #[tracing::instrument(skip(self, context), fields(resource_name))]
79    async fn get_function(
80        &self,
81        request: GetFunctionRequest,
82        context: RequestContext,
83    ) -> Result<Function> {
84        tracing::Span::current().record("resource_name", &request.name);
85        self.check_required(&request, &context).await?;
86        Ok(self.get(&request.resource()).await?.0.try_into()?)
87    }
88
89    #[tracing::instrument(skip(self, context), fields(resource_name))]
90    async fn update_function(
91        &self,
92        request: UpdateFunctionRequest,
93        context: RequestContext,
94    ) -> Result<Function> {
95        tracing::Span::current().record("resource_name", &request.name);
96        self.check_required(&request, &context).await?;
97        let ident = request.resource();
98        let resource = Function {
99            owner: request.owner,
100            ..Default::default()
101        };
102        Ok(self.update(&ident, resource.into()).await?.0.try_into()?)
103    }
104
105    #[tracing::instrument(skip(self, context), fields(resource_name))]
106    async fn delete_function(
107        &self,
108        request: DeleteFunctionRequest,
109        context: RequestContext,
110    ) -> Result<()> {
111        tracing::Span::current().record("resource_name", &request.name);
112        self.check_required(&request, &context).await?;
113        Ok(self.delete(&request.resource()).await?)
114    }
115}
116
117impl SecuredAction for CreateFunctionRequest {
118    fn resource(&self) -> ResourceIdent {
119        let info = self.function_info.as_option();
120        ResourceIdent::function(ResourceName::new([
121            info.map(|i| i.catalog_name.as_str()).unwrap_or_default(),
122            info.map(|i| i.schema_name.as_str()).unwrap_or_default(),
123            info.map(|i| i.name.as_str()).unwrap_or_default(),
124        ]))
125    }
126
127    fn permission(&self) -> &'static Permission {
128        &Permission::Create
129    }
130}
131
132impl SecuredAction for ListFunctionsRequest {
133    fn resource(&self) -> ResourceIdent {
134        ResourceIdent::function(ResourceName::new([
135            self.catalog_name.as_str(),
136            self.schema_name.as_str(),
137        ]))
138    }
139
140    fn permission(&self) -> &'static Permission {
141        &Permission::Read
142    }
143}
144
145impl SecuredAction for GetFunctionRequest {
146    fn resource(&self) -> ResourceIdent {
147        ResourceIdent::function(ResourceName::from_naive_str_split(self.name.as_str()))
148    }
149
150    fn permission(&self) -> &'static Permission {
151        &Permission::Read
152    }
153}
154
155impl SecuredAction for UpdateFunctionRequest {
156    fn resource(&self) -> ResourceIdent {
157        ResourceIdent::function(ResourceName::from_naive_str_split(self.name.as_str()))
158    }
159
160    fn permission(&self) -> &'static Permission {
161        &Permission::Manage
162    }
163}
164
165impl SecuredAction for DeleteFunctionRequest {
166    fn resource(&self) -> ResourceIdent {
167        ResourceIdent::function(ResourceName::from_naive_str_split(self.name.as_str()))
168    }
169
170    fn permission(&self) -> &'static Permission {
171        &Permission::Manage
172    }
173}
unitycatalog_server/api/functions.rs

unitycatalog_server/api/
functions.rs
