feat: add pg_settings view

Author: sunng87

datafusion-postgres/src/pg_catalog.rs

@@ -24,6 +24,7 @@ mod pg_attribute;
 mod pg_class;
 mod pg_database;
 mod pg_namespace;
+mod pg_settings;
 
 const PG_CATALOG_TABLE_PG_AGGREGATE: &str = "pg_aggregate";
 const PG_CATALOG_TABLE_PG_AM: &str = "pg_am";
@@ -86,6 +87,7 @@ const PG_CATALOG_TABLE_PG_SUBSCRIPTION_REL: &str = "pg_subscription_rel";
 const PG_CATALOG_TABLE_PG_TABLESPACE: &str = "pg_tablespace";
 const PG_CATALOG_TABLE_PG_TRIGGER: &str = "pg_trigger";
 const PG_CATALOG_TABLE_PG_USER_MAPPING: &str = "pg_user_mapping";
+const PG_CATALOG_VIEW_PG_SETTINGS: &str = "pg_settings";
 
 /// Determine PostgreSQL table type (relkind) from DataFusion TableProvider
 fn get_table_type(table: &Arc<dyn TableProvider>) -> &'static str {
@@ -180,6 +182,7 @@ pub const PG_CATALOG_TABLES: &[&str] = &[
     PG_CATALOG_TABLE_PG_TABLESPACE,
     PG_CATALOG_TABLE_PG_TRIGGER,
     PG_CATALOG_TABLE_PG_USER_MAPPING,
+    PG_CATALOG_VIEW_PG_SETTINGS,
 ];
 
 #[derive(Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
@@ -345,6 +348,10 @@ impl SchemaProvider for PgCatalogSchemaProvider {
                     StreamingTable::try_new(Arc::clone(table.schema()), vec![table]).unwrap(),
                 )))
             }
+            PG_CATALOG_VIEW_PG_SETTINGS => {
+                let table = pg_settings::PgSettingsView::try_new()?;
+                Ok(Some(Arc::new(table.try_into_memtable()?)))
+            }
 
             _ => Ok(None),
         }

datafusion-postgres/src/pg_catalog/pg_settings.rs

@@ -0,0 +1,115 @@
+use std::sync::Arc;
+
+use datafusion::arrow::array::{ArrayRef, BooleanArray, Int32Array, RecordBatch, StringArray};
+use datafusion::arrow::datatypes::{DataType, Field, Schema, SchemaRef};
+use datafusion::catalog::MemTable;
+use datafusion::error::Result;
+
+#[derive(Debug, Clone)]
+pub(crate) struct PgSettingsView {
+    schema: SchemaRef,
+    data: Vec<RecordBatch>,
+}
+
+impl PgSettingsView {
+    pub(crate) fn try_new() -> Result<PgSettingsView> {
+        let schema = Arc::new(Schema::new(vec![
+            //        name        | setting | unit |                             category                             |                short_
+            //desc                |                                                   extra_desc
+            //| context | vartype | source  | min_val | max_val | enumvals |
+            //boot_val | reset_val | sourcefile | sourceline | pending_restart
+            Field::new("name", DataType::Utf8, true),
+            Field::new("setting", DataType::Utf8, true),
+            Field::new("unit", DataType::Utf8, true),
+            Field::new("category", DataType::Utf8, true),
+            Field::new("short_desc", DataType::Utf8, true),
+            Field::new("extra_desc", DataType::Utf8, true),
+            Field::new("context", DataType::Utf8, true),
+            Field::new("vartype", DataType::Utf8, true),
+            Field::new("source", DataType::Utf8, true),
+            Field::new("min_val", DataType::Utf8, true),
+            Field::new("max_val", DataType::Utf8, true),
+            Field::new("enumvals", DataType::Utf8, true),
+            Field::new("bool_val", DataType::Utf8, true),
+            Field::new("reset_val", DataType::Utf8, true),
+            Field::new("sourcefile", DataType::Utf8, true),
+            Field::new("sourceline", DataType::Int32, true),
+            Field::new("pending_restart", DataType::Boolean, true),
+        ]));
+
+        let data = Self::create_data(schema.clone())?;
+
+        Ok(Self { schema, data })
+    }
+
+    fn create_data(schema: Arc<Schema>) -> Result<Vec<RecordBatch>> {
+        let mut name: Vec<Option<&str>> = Vec::new();
+        let mut setting: Vec<Option<&str>> = Vec::new();
+        let mut unit: Vec<Option<&str>> = Vec::new();
+        let mut category: Vec<Option<&str>> = Vec::new();
+        let mut short_desc: Vec<Option<&str>> = Vec::new();
+        let mut extra_desc: Vec<Option<&str>> = Vec::new();
+        let mut context: Vec<Option<&str>> = Vec::new();
+        let mut vartype: Vec<Option<&str>> = Vec::new();
+        let mut source: Vec<Option<&str>> = Vec::new();
+        let mut min_val: Vec<Option<&str>> = Vec::new();
+        let mut max_val: Vec<Option<&str>> = Vec::new();
+        let mut enumvals: Vec<Option<&str>> = Vec::new();
+        let mut bool_val: Vec<Option<&str>> = Vec::new();
+        let mut reset_val: Vec<Option<&str>> = Vec::new();
+        let mut sourcefile: Vec<Option<&str>> = Vec::new();
+        let mut sourceline: Vec<Option<i32>> = Vec::new();
+        let mut pending_restart: Vec<Option<bool>> = Vec::new();
+
+        let data = vec![("standard_conforming_strings", "on")];
+
+        for (setting_name, setting_val) in data {
+            name.push(Some(setting_name));
+            setting.push(Some(setting_val));
+
+            unit.push(None);
+            category.push(None);
+            short_desc.push(None);
+            extra_desc.push(None);
+            context.push(None);
+            vartype.push(None);
+            source.push(None);
+            min_val.push(None);
+            max_val.push(None);
+            enumvals.push(None);
+            bool_val.push(None);
+            reset_val.push(None);
+            sourcefile.push(None);
+            sourceline.push(None);
+            pending_restart.push(None);
+        }
+
+        let arrays: Vec<ArrayRef> = vec![
+            Arc::new(StringArray::from(name)),
+            Arc::new(StringArray::from(setting)),
+            Arc::new(StringArray::from(unit)),
+            Arc::new(StringArray::from(category)),
+            Arc::new(StringArray::from(short_desc)),
+            Arc::new(StringArray::from(extra_desc)),
+            Arc::new(StringArray::from(context)),
+            Arc::new(StringArray::from(vartype)),
+            Arc::new(StringArray::from(source)),
+            Arc::new(StringArray::from(min_val)),
+            Arc::new(StringArray::from(max_val)),
+            Arc::new(StringArray::from(enumvals)),
+            Arc::new(StringArray::from(bool_val)),
+            Arc::new(StringArray::from(reset_val)),
+            Arc::new(StringArray::from(sourcefile)),
+            Arc::new(Int32Array::from(sourceline)),
+            Arc::new(BooleanArray::from(pending_restart)),
+        ];
+
+        let batch = RecordBatch::try_new(schema.clone(), arrays)?;
+
+        Ok(vec![batch])
+    }
+
+    pub(crate) fn try_into_memtable(self) -> Result<MemTable> {
+        MemTable::try_new(self.schema, vec![self.data])
+    }
+}