1use std::sync::Arc;
16
17use common_catalog::consts::{
18 DEFAULT_PRIVATE_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, PG_CATALOG_NAME,
19};
20use datafusion::arrow::array::{ArrayRef, StringArray, StringBuilder, as_boolean_array};
21use datafusion::catalog::TableFunction;
22use datafusion::common::ScalarValue;
23use datafusion::common::utils::SingleRowListArrayBuilder;
24use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, Signature, TypeSignature, Volatility};
25use datafusion_pg_catalog::pg_catalog::{self, PgCatalogStaticTables};
26use datatypes::arrow::datatypes::{DataType, Field};
27use derive_more::derive::Display;
28
29use crate::function::{Function, find_function_context};
30use crate::function_registry::FunctionRegistry;
31use crate::system::define_nullary_udf;
32
33const CURRENT_SCHEMA_FUNCTION_NAME: &str = "current_schema";
34const CURRENT_SCHEMAS_FUNCTION_NAME: &str = "current_schemas";
35const SESSION_USER_FUNCTION_NAME: &str = "session_user";
36const CURRENT_DATABASE_FUNCTION_NAME: &str = "current_database";
37const OBJ_DESCRIPTION_FUNCTION_NAME: &str = "obj_description";
38const COL_DESCRIPTION_FUNCTION_NAME: &str = "col_description";
39const SHOBJ_DESCRIPTION_FUNCTION_NAME: &str = "shobj_description";
40const PG_MY_TEMP_SCHEMA_FUNCTION_NAME: &str = "pg_my_temp_schema";
41
42define_nullary_udf!(CurrentSchemaFunction);
43define_nullary_udf!(SessionUserFunction);
44define_nullary_udf!(CurrentDatabaseFunction);
45define_nullary_udf!(PgMyTempSchemaFunction);
46
47impl Function for CurrentDatabaseFunction {
48 fn name(&self) -> &str {
49 CURRENT_DATABASE_FUNCTION_NAME
50 }
51
52 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
53 Ok(DataType::Utf8View)
54 }
55
56 fn signature(&self) -> &Signature {
57 &self.signature
58 }
59
60 fn invoke_with_args(
61 &self,
62 args: ScalarFunctionArgs,
63 ) -> datafusion_common::Result<ColumnarValue> {
64 let func_ctx = find_function_context(&args)?;
65 let db = func_ctx.query_ctx.current_catalog().to_string();
66
67 Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(Some(db))))
68 }
69}
70
71impl Function for CurrentSchemaFunction {
74 fn name(&self) -> &str {
75 CURRENT_SCHEMA_FUNCTION_NAME
76 }
77
78 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
79 Ok(DataType::Utf8View)
80 }
81
82 fn signature(&self) -> &Signature {
83 &self.signature
84 }
85
86 fn invoke_with_args(
87 &self,
88 args: ScalarFunctionArgs,
89 ) -> datafusion_common::Result<ColumnarValue> {
90 let func_ctx = find_function_context(&args)?;
91 let db = func_ctx.query_ctx.current_schema();
92
93 Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(
94 (!db.is_empty()).then_some(db),
95 )))
96 }
97}
98
99impl Function for SessionUserFunction {
100 fn name(&self) -> &str {
101 SESSION_USER_FUNCTION_NAME
102 }
103
104 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
105 Ok(DataType::Utf8View)
106 }
107
108 fn signature(&self) -> &Signature {
109 &self.signature
110 }
111
112 fn invoke_with_args(
113 &self,
114 args: ScalarFunctionArgs,
115 ) -> datafusion_common::Result<ColumnarValue> {
116 let func_ctx = find_function_context(&args)?;
117 let user = func_ctx.query_ctx.current_user();
118
119 Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(Some(
120 user.username().to_string(),
121 ))))
122 }
123}
124
125#[derive(Display, Debug)]
126#[display("{}", self.name())]
127pub(super) struct CurrentSchemasFunction {
128 signature: Signature,
129}
130
131impl CurrentSchemasFunction {
132 pub fn new() -> Self {
133 Self {
134 signature: Signature::new(
135 TypeSignature::Exact(vec![DataType::Boolean]),
136 Volatility::Stable,
137 ),
138 }
139 }
140}
141
142impl Function for CurrentSchemasFunction {
143 fn name(&self) -> &str {
144 CURRENT_SCHEMAS_FUNCTION_NAME
145 }
146
147 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
148 Ok(DataType::List(Arc::new(Field::new(
149 "item",
150 DataType::Utf8,
151 true,
152 ))))
153 }
154
155 fn signature(&self) -> &Signature {
156 &self.signature
157 }
158
159 fn invoke_with_args(
160 &self,
161 args: ScalarFunctionArgs,
162 ) -> datafusion_common::Result<ColumnarValue> {
163 let func_ctx = find_function_context(&args)?;
164 let schema = func_ctx.query_ctx.current_schema();
165 let args = ColumnarValue::values_to_arrays(&args.args)?;
166 let input = as_boolean_array(&args[0]);
167
168 let mut values = Vec::new();
169 if !schema.is_empty() {
170 values.push(schema.as_str());
171 }
172 if input.value(0) {
174 values.push(INFORMATION_SCHEMA_NAME);
175 values.push(PG_CATALOG_NAME);
176 values.push(DEFAULT_PRIVATE_SCHEMA_NAME);
177 }
178
179 let list_array = SingleRowListArrayBuilder::new(Arc::new(StringArray::from(values)));
180
181 let array: ArrayRef = Arc::new(list_array.build_list_array());
182
183 Ok(ColumnarValue::Array(array))
184 }
185}
186
187#[derive(Display, Debug, Clone)]
189#[display("{}", self.name())]
190pub(super) struct ObjDescriptionFunction {
191 signature: Signature,
192}
193
194impl ObjDescriptionFunction {
195 pub fn new() -> Self {
196 Self {
197 signature: Signature::one_of(
198 vec![
199 TypeSignature::Exact(vec![DataType::Int64, DataType::Utf8]),
200 TypeSignature::Exact(vec![DataType::UInt32, DataType::Utf8]),
201 TypeSignature::Exact(vec![DataType::Int64]),
202 TypeSignature::Exact(vec![DataType::UInt32]),
203 ],
204 Volatility::Stable,
205 ),
206 }
207 }
208}
209
210impl Function for ObjDescriptionFunction {
211 fn name(&self) -> &str {
212 OBJ_DESCRIPTION_FUNCTION_NAME
213 }
214
215 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
216 Ok(DataType::Utf8)
217 }
218
219 fn signature(&self) -> &Signature {
220 &self.signature
221 }
222
223 fn invoke_with_args(
224 &self,
225 args: ScalarFunctionArgs,
226 ) -> datafusion_common::Result<ColumnarValue> {
227 let num_rows = args.number_rows;
228 let mut builder = StringBuilder::with_capacity(num_rows, 0);
229 for _ in 0..num_rows {
230 builder.append_null();
231 }
232 Ok(ColumnarValue::Array(Arc::new(builder.finish())))
233 }
234}
235
236#[derive(Display, Debug, Clone)]
238#[display("{}", self.name())]
239pub(super) struct ColDescriptionFunction {
240 signature: Signature,
241}
242
243impl ColDescriptionFunction {
244 pub fn new() -> Self {
245 Self {
246 signature: Signature::one_of(
247 vec![
248 TypeSignature::Exact(vec![DataType::Int64, DataType::Int32]),
249 TypeSignature::Exact(vec![DataType::UInt32, DataType::Int32]),
250 TypeSignature::Exact(vec![DataType::Int64, DataType::Int64]),
251 TypeSignature::Exact(vec![DataType::UInt32, DataType::Int64]),
252 ],
253 Volatility::Stable,
254 ),
255 }
256 }
257}
258
259impl Function for ColDescriptionFunction {
260 fn name(&self) -> &str {
261 COL_DESCRIPTION_FUNCTION_NAME
262 }
263
264 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
265 Ok(DataType::Utf8)
266 }
267
268 fn signature(&self) -> &Signature {
269 &self.signature
270 }
271
272 fn invoke_with_args(
273 &self,
274 args: ScalarFunctionArgs,
275 ) -> datafusion_common::Result<ColumnarValue> {
276 let num_rows = args.number_rows;
277 let mut builder = StringBuilder::with_capacity(num_rows, 0);
278 for _ in 0..num_rows {
279 builder.append_null();
280 }
281 Ok(ColumnarValue::Array(Arc::new(builder.finish())))
282 }
283}
284
285#[derive(Display, Debug, Clone)]
287#[display("{}", self.name())]
288pub(super) struct ShobjDescriptionFunction {
289 signature: Signature,
290}
291
292impl ShobjDescriptionFunction {
293 pub fn new() -> Self {
294 Self {
295 signature: Signature::one_of(
296 vec![
297 TypeSignature::Exact(vec![DataType::Int64, DataType::Utf8]),
298 TypeSignature::Exact(vec![DataType::UInt64, DataType::Utf8]),
299 TypeSignature::Exact(vec![DataType::Int32, DataType::Utf8]),
300 TypeSignature::Exact(vec![DataType::UInt32, DataType::Utf8]),
301 ],
302 Volatility::Stable,
303 ),
304 }
305 }
306}
307
308impl Function for ShobjDescriptionFunction {
309 fn name(&self) -> &str {
310 SHOBJ_DESCRIPTION_FUNCTION_NAME
311 }
312
313 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
314 Ok(DataType::Utf8)
315 }
316
317 fn signature(&self) -> &Signature {
318 &self.signature
319 }
320
321 fn invoke_with_args(
322 &self,
323 args: ScalarFunctionArgs,
324 ) -> datafusion_common::Result<ColumnarValue> {
325 let num_rows = args.number_rows;
326 let mut builder = StringBuilder::with_capacity(num_rows, 0);
327 for _ in 0..num_rows {
328 builder.append_null();
329 }
330 Ok(ColumnarValue::Array(Arc::new(builder.finish())))
331 }
332}
333
334impl Function for PgMyTempSchemaFunction {
336 fn name(&self) -> &str {
337 PG_MY_TEMP_SCHEMA_FUNCTION_NAME
338 }
339
340 fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
341 Ok(DataType::UInt32)
342 }
343
344 fn signature(&self) -> &Signature {
345 &self.signature
346 }
347
348 fn invoke_with_args(
349 &self,
350 _args: ScalarFunctionArgs,
351 ) -> datafusion_common::Result<ColumnarValue> {
352 Ok(ColumnarValue::Scalar(ScalarValue::UInt32(Some(0))))
353 }
354}
355
356pub(super) struct PGCatalogFunction;
357
358impl PGCatalogFunction {
359 pub fn register(registry: &FunctionRegistry) {
360 let static_tables =
361 Arc::new(PgCatalogStaticTables::try_new().expect("load postgres static tables"));
362
363 registry.register_scalar(CurrentSchemaFunction::default());
364 registry.register_scalar(CurrentSchemasFunction::new());
365 registry.register_scalar(SessionUserFunction::default());
366 registry.register_scalar(CurrentDatabaseFunction::default());
367 registry.register(pg_catalog::format_type::create_format_type_udf());
368 registry.register(pg_catalog::create_pg_get_partkeydef_udf());
369 registry.register(pg_catalog::has_privilege_udf::create_has_privilege_udf(
370 "has_table_privilege",
371 ));
372 registry.register(pg_catalog::has_privilege_udf::create_has_privilege_udf(
373 "has_schema_privilege",
374 ));
375 registry.register(pg_catalog::has_privilege_udf::create_has_privilege_udf(
376 "has_database_privilege",
377 ));
378 registry.register(pg_catalog::has_privilege_udf::create_has_privilege_udf(
379 "has_any_column_privilege",
380 ));
381 registry.register_table_function(TableFunction::new(
382 "pg_get_keywords".to_string(),
383 static_tables.pg_get_keywords.clone(),
384 ));
385 registry.register(pg_catalog::create_pg_relation_is_publishable_udf());
386 registry.register(pg_catalog::create_pg_get_statisticsobjdef_columns_udf());
387 registry.register(pg_catalog::create_pg_get_userbyid_udf());
388 registry.register(pg_catalog::create_pg_table_is_visible());
389 registry.register(pg_catalog::pg_get_expr_udf::create_pg_get_expr_udf());
390 registry.register(pg_catalog::create_pg_encoding_to_char_udf());
391 registry.register(pg_catalog::create_pg_relation_size_udf());
392 registry.register(pg_catalog::create_pg_total_relation_size_udf());
393 registry.register(pg_catalog::create_pg_stat_get_numscans());
394 registry.register(pg_catalog::create_pg_get_constraintdef());
395 registry.register(pg_catalog::create_pg_get_partition_ancestors_udf());
396 registry.register(pg_catalog::quote_ident_udf::create_quote_ident_udf());
397 registry.register(pg_catalog::quote_ident_udf::create_parse_ident_udf());
398 registry.register(pg_catalog::array_bounds_udf::create_array_upper_udf());
400 registry.register(pg_catalog::array_bounds_udf::create_array_lower_udf());
401 registry.register_scalar(ObjDescriptionFunction::new());
402 registry.register_scalar(ColDescriptionFunction::new());
403 registry.register_scalar(ShobjDescriptionFunction::new());
404 registry.register_scalar(PgMyTempSchemaFunction::default());
405 }
406}
407
408#[cfg(test)]
409mod tests {
410 use std::sync::Arc;
411
412 use arrow_schema::Field;
413 use datafusion::arrow::array::Array;
414 use datafusion_common::ScalarValue;
415 use datafusion_expr::ColumnarValue;
416
417 use super::*;
418
419 fn create_test_args(args: Vec<ColumnarValue>, number_rows: usize) -> ScalarFunctionArgs {
420 ScalarFunctionArgs {
421 args,
422 arg_fields: vec![],
423 number_rows,
424 return_field: Arc::new(Field::new("result", DataType::Utf8, true)),
425 config_options: Arc::new(Default::default()),
426 }
427 }
428
429 #[test]
430 fn test_obj_description_function() {
431 let func = ObjDescriptionFunction::new();
432 assert_eq!("obj_description", func.name());
433 assert_eq!(DataType::Utf8, func.return_type(&[]).unwrap());
434
435 let args = create_test_args(
436 vec![
437 ColumnarValue::Scalar(ScalarValue::Int64(Some(1234))),
438 ColumnarValue::Scalar(ScalarValue::Utf8(Some("pg_class".to_string()))),
439 ],
440 1,
441 );
442 let result = func.invoke_with_args(args).unwrap();
443 if let ColumnarValue::Array(arr) = result {
444 assert_eq!(1, arr.len());
445 assert!(arr.is_null(0));
446 } else {
447 panic!("Expected Array result");
448 }
449 }
450
451 #[test]
452 fn test_col_description_function() {
453 let func = ColDescriptionFunction::new();
454 assert_eq!("col_description", func.name());
455 assert_eq!(DataType::Utf8, func.return_type(&[]).unwrap());
456
457 let args = create_test_args(
458 vec![
459 ColumnarValue::Scalar(ScalarValue::Int64(Some(1234))),
460 ColumnarValue::Scalar(ScalarValue::Int64(Some(1))),
461 ],
462 1,
463 );
464 let result = func.invoke_with_args(args).unwrap();
465 if let ColumnarValue::Array(arr) = result {
466 assert_eq!(1, arr.len());
467 assert!(arr.is_null(0));
468 } else {
469 panic!("Expected Array result");
470 }
471 }
472
473 #[test]
474 fn test_shobj_description_function() {
475 let func = ShobjDescriptionFunction::new();
476 assert_eq!("shobj_description", func.name());
477 assert_eq!(DataType::Utf8, func.return_type(&[]).unwrap());
478
479 let args = create_test_args(
480 vec![
481 ColumnarValue::Scalar(ScalarValue::Int64(Some(1))),
482 ColumnarValue::Scalar(ScalarValue::Utf8(Some("pg_database".to_string()))),
483 ],
484 1,
485 );
486 let result = func.invoke_with_args(args).unwrap();
487 if let ColumnarValue::Array(arr) = result {
488 assert_eq!(1, arr.len());
489 assert!(arr.is_null(0));
490 } else {
491 panic!("Expected Array result");
492 }
493 }
494}