Skip to main content

common_function/system/
pg_catalog.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use 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
71// Though "current_schema" can be aliased to "database", to not cause any breaking changes,
72// we are not doing it: not until https://github.com/apache/datafusion/issues/17469 is resolved.
73impl 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        // include implicit schemas
173        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/// PostgreSQL obj_description - returns NULL for compatibility
188#[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/// PostgreSQL col_description - returns NULL for compatibility
237#[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/// PostgreSQL shobj_description - returns NULL for compatibility
286#[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
334/// PostgreSQL pg_my_temp_schema - returns 0 (no temp schema) for compatibility
335impl 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        // Register array bound UDFs used by pg_catalog views.
399        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}